/goal

/goal is the slash command that turns Eight from a chat partner into an autonomous loop. You state a measurable outcome, and Eight runs turn after turn - choosing tools, taking actions, checking its own progress - until a separate judge model declares the goal met or the budget runs out.

What's different from `/go` in other agents

Hermes and Codex both shipped a similar primitive in April 2026. Their judge models are cloud-tethered. Ours is not.

Executor and judge both run on your machine via the failover chain: Apple Foundation Model on M-series Macs, Ollama, or LM Studio. Cloud opt-in only.
Anti-collusion is a hard constructor check: the judge model must be different from the executor model. Self-grading is rejected.
Judge fails open: a broken or missing judge never wedges the loop. The turn budget is the real backstop.
Append-only HMAC-signed ledger at ~/.8gent/runs/{runId}/ledger.jsonl for every autonomous run. Tamper-detected, audit-clean.
Capability budget per run: wall-clock, tool calls, cloud-USD, files modified, network egress. Enforced at the daemon layer, not overridable by the agent.
Hardcoded deny-list: rm -rf outside /tmp, git push --force to main, npm publish, sudo, financial-domain HTTP calls. The agent cannot mint exceptions.

Usage

/goal organize my Downloads folder by file type and date, dedupe, surface anything sketchy
/goal create /tmp/notes.md with a summary of today's git log
/goal find every plaintext credential leak in my home directory, write the report to /tmp/secret-audit.csv

Subcommands:

/goal status     show what's happening now
/goal stop       abort the current run (state preserved)
/goal resume     continue a paused run
/goal clear      stop and drop the run state entirely
/subgoal <text>  inject a sub-goal into the running loop
/goal ?          show this help inline

The TUI's living plan rail (right side) reflects every goal-related task as it's created and updated. The status overlay on the focal strip shows current turn count, sub-goal, and elapsed time.

When to use it

Walk-away tasks: anything that would take you 10+ chat turns to babysit.
Bulk operations: rename 500 files, normalize 10,000 CSV rows, dedupe across folders.
Privacy-locked work: scan local files for credentials, audit configs, anything that should not leave your machine.
Overnight runs: long-running data migrations or refactors. Local executor means no per-token cost while you sleep.

When not to use it

Single one-shot questions ("explain this function") - just ask.
Open-ended creative work where "done" is subjective.
Tasks where you need to inspect each step before continuing.
Anything you are not willing to let run unattended.

Anatomy of a goal run

1. You type:           /goal create /tmp/eight-test.txt with content "works"
2. Goal-loop starts:   runId issued, ledger opened, capability budget locked
3. Turn loop:
   - Executor (local model) acts via Eight's agent loop
   - Judge (different local model) reads the turn summary, returns
     {decision: "continue" | "satisfied" | "failed", confidence, reason}
   - Budget counters update; deny-list checked on every tool call
   - Plan rail + LiveFocalStrip overlay update
4. Stop conditions (whichever fires first):
   - Judge returns satisfied with confidence >= floor
   - Judge dissent streak hits the configured ceiling
   - Wall-clock, turn, or token budget exhausted
   - User runs /goal stop
5. Receipt assembled:  verdict + evidence link + cost + duration + sub-agents
6. Ledger sealed:      final hash chain entry, persistence row marked complete

Configuration

Defaults live in the daemon config; per-run overrides on the command line:

/goal --max-turns 50 --max-wallclock 30m --judge anthropic/claude-haiku-4-5 "<goal>"

Without flags, the daemon uses local-first defaults: executor and judge both routed through the local failover chain, 2-hour wall-clock cap, 500 tool-call cap, zero cloud USD.

On this page