Run autonomous coding agents until verifiable goals complete

/goal is a slash command (internally called the "Ralph loop") that turns an agent prompt into a persistent agent looping plan, act, test, review, iterate until a stop condition is met, the user pauses, or the token budget runs out. Available today on Codex, Claude Code, and Hermes Agent. Its key difference from a normal prompt: when a turn ends but the goal isn't met, the agent auto-continues instead of waiting for input, moving through lifecycle states of pursuing, paused, achieved, unmet, and budget-limited. It is not a budget command, a safety boundary, a "run forever" switch, or a replacement for /plan - it's a contract enforcer with a built-in verification loop.

Use /goal only when all three are true: the task is more than 30 minutes of mechanical work, there is a verifiable stop condition (tests pass, coverage hit, an eval score reached, build green), and the repo is agent-ready (working build, decent tests, an AGENTS.md file present). It fits migrations, coverage lifts, TDD feature builds, refactors with contract tests, prompt/eval optimization, deploy retry loops, and bug-repro-then-fix work. It's a bad fit for exploratory work, vague "improve this" requests, anything without a real "done" definition, prod credentials, or destructive shared-infra operations. It requires subscription auth - API-key auth does not work, and a pro-tier plan is the realistic minimum for long runs.

Every goal needs a 5-part contract: a one-sentence Objective naming a single concrete outcome; Constraints on what must NOT change (public API, files, libraries, conventions); a Validation command - the exact shell command that proves progress; a verifiable Stop condition ("stop when X passes" or "when further changes need human/product input"); and a Documentation instruction committing the agent to concise, targeted docs for every change. For example:

**Objective:** Migrate this project from Pydantic v1 to v2.
**Read first:** pyproject.toml, src/, tests/
**Constraints:** no public API changes; keep imports backwards-compatible via shims if needed; no new dependencies
**Validate:** `pytest -q` after each change
**Checkpoints:** work in checkpoints; log progress briefly
**Stop when:** full suite passes with zero deprecation warnings, OR when a change requires architecture decisions

Writing rules: one objective and one stop condition, never a backlog; documentation is mandatory in every prompt; never instruct the agent to create new ADRs, since those require the user's explicit approval; explicitly forbid reward-hacking ("Do not delete, skip, weaken, or narrow tests to make the goal pass"); keep the objective under a 4,000-character limit, moving longer detail into a PLAN.md/GOAL_BRIEF.md file the goal points to; use literal strings for paths, commands, and issue numbers; explicitly forbid scope creep ("Do not refactor unrelated code. Do not add dependencies"); and tell the agent when to pause on a named condition. Launching it: cd into the repo (goals run scoped to the working directory), launch the agent bare in TUI mode - never exec/headless, since /goal is a TUI-only slash command - sign in with subscription auth, type /goal <your contract> in the composer, and walk away.

A running goal is controlled with /goal commands: bare /goal shows status (current checkpoint, what's verified, what remains, blockers); /goal pause freezes it; /goal resume unfreezes it (paused goals never auto-resume); /goal clear kills it; /goal <new> replaces the current contract; and Ctrl+C or any typed message auto-pauses it, since user input always wins priority. Goal state persists server-side across sessions - cd back into the repo, launch the agent, check /goal for status, then /goal resume. A budget-limited goal doesn't stop abruptly: it summarizes progress, notes what's left, saves state, and resumes after a budget refresh or upgrade. When a goal drifts, a minor correction can just be typed into the composer (auto-pauses, folds it in, resumes); a loose objective calls for /goal pause, reading status, then replacing the contract with a tighter /goal <version> rather than piling instructions onto a vague goal; and a genuinely bad mess calls for /goal clear, a git status/git stash, and a fresh rewrite - a drifting goal left running "to see where it goes" just burns tokens as diffs compound. The highest-leverage technique for writing a goal is meta-prompting: have a second AI session inspect the codebase, surface hidden assumptions and edge cases, and emit the structured /goal block itself, which produces order-of-magnitude better runs than a hand-written goal. Agents can also self-set a goal natively via the create_goal tool - hand it your high-level intent plus the same raw materials and tell it to write and pursue its own /goal, adding an instruction to ask clarifying questions first if the intent is underspecified. Recurring policy (adversarial self-review before declaring done, an extra QA pass even when tests pass, the standard validation command) can be baked into AGENTS.md so every goal inherits it automatically. Common troubleshooting: a missing /goal in the slash popup means the agent needs updating; a feature flag on but the command still missing means a full restart is needed; /goal is singular, not /goals; a goal that won't activate needs a sign-out/sign-in with subscription auth; a goal stopped with a progress summary is budget-limited and needs /goal resume after refresh; /goal resume reporting no active goal means it's in a terminal or cleared state and needs a fresh /goal <new>; and a goal that looks active but won't auto-continue is likely stuck in Plan mode, which doesn't trigger continuation.

Anyone running long, mechanical, well-scoped agent work (migrations, coverage lifts, refactors, TDD builds) who wants a persistent, self-continuing agent loop instead of manually re-prompting after every turn - always reviewing the diff before merging, since long autonomy means more code to validate, not less.