How to Run Claude Code and Codex Overnight via /goal in 2026: 14-Hour Autonomous Mode

Information about working with Ailoot is available in the documentation.

What Is /goal and Why Did It Appear in 2026?#

The scenario we all lived with before April 2026: I give Claude a task, “migrate the project from Pydantic v1 to v2.” It starts, stops after 30 seconds, I look at what it did, write “continue,” it takes the next step, stops, and I write “continue” again. On a large migration, that means 200–300 manual “continues,” and I am effectively babysitting the agent instead of writing other code in parallel.

OpenAI’s analysis was that the problem was not model “stupidity,” but the architecture of the loop. The model did not know when to stop, so it hit the brakes on every turn. Give it a “done” criterion, and it will decide for itself.

That is how /goal came about—a mechanism built into the harness, not the model.

How Do You Set Up Goal Mode in Claude Code?#

A minimal example from Anthropic’s official documentation:

claude -p "/goal CHANGELOG.md has an entry for every PR merged this week"

This command launches the agent in the background with one goal. Claude finds the PRs, checks them against CHANGELOG.md, adds any missing lines, and stops when the criterion is met.

In interactive mode, just type /goal followed by the condition:

/goal all pytest tests pass and mypy strict reports zero errors

What Claude does next:

• After each turn, a separate fast model (Haiku by default) receives the current condition and conversation history
• This model answers “yes” or “no” with a short reason
• If the answer is “no,” Claude automatically takes another turn without returning control to you
• If the answer is “yes,” the goal is cleared and control returns to you

Hard limits no one tells you about until you run into them:

• /goal works only in working directories where the trust dialog has been accepted. If you are on a new machine and Claude has not yet remembered that directory, the command will fail
• In corporate settings with disableAllHooks or allowManagedHooksOnly, the command is unavailable
• The condition can be up to 4,000 characters long
• Only one goal can be active per session. A new /goal resets the old one
• With --resume, the condition is preserved, but the turn, time, and token counters reset

Control commands:

• /goal with no argument—show the current status
• /goal clear (or stop, off, reset, none, cancel)—clear the goal

According to Anthropic, the evaluator’s cost is “usually negligible compared with the cost of the main turn.” Haiku evaluates the criterion and conversation text and does not call tools, so the check is cheap; the expensive part is the main model’s turns.

How Do You Set Up /goal in Codex CLI?#

The command looks the same as in Claude:

codex
> /goal all vitest tests pass and there are no eslint errors

Codex offers more goal controls:

The main difference from Claude is that Codex itself checks whether it is “done,” rather than a separate model. After each turn, Codex automatically inserts the continuation.md template from the openai/codex repository into the context. A literal translation:

“Continue working toward the active thread goal. Do not repeat work already done. Choose the next concrete action toward the goal. Mark the goal achieved only when an audit shows that the goal has actually been met and no required work remains.”

When the tokens approach their limit, a second template—budget_limit.md—is inserted:

“The goal has reached its token limit. Do not start substantial new work. Wrap up this turn as soon as possible: summarize useful progress, identify remaining work and blockers, and leave the user with a clear next step.”

The logic is the same: “do not lie about what you did.” Continuation requires continuing only if the goal has genuinely not been met. Budget_limit requires stopping, but honestly describing what remains.

Unlike Claude, Codex ties the goal to the thread, not the session. For example, you can close the terminal and open it again in the morning, and /goal resume picks up the same goal with the same facts in memory. This is useful for runs you split into chunks according to your own schedule.

How Does /goal in Claude Code Differ from /goal in Codex?#

This is the most common gap in comparisons, so let’s look at it in detail.

The conceptual difference is that Claude treats the loop as a quality contract (an external evaluator), while Codex treats it as an execution mechanism (the agent manages itself).

In practice, this means: if you want the “done” criterion to be impartial, choose Claude. If you want the agent to be able to check files and logs while evaluating, choose Codex.

Read more about the tools themselves in the Codex vs Claude Code guide.

Real Example: Migrating from Pydantic v1 to v2 in 31 Hours#

The task was set as follows: “migrate from Pydantic v1 to v2, all pytest tests must pass, and mypy strict must report zero errors.”

What happened:

• Session 1 (8 hours)—Codex analyzed the imports, rewrote BaseModel declarations, and set up mypy
• Session 2 (10 hours)—rewrote validators and broke about 200 tests
• Session 3 (7 hours)—fixed the tests and found circular dependencies
• Session 4 (6 hours)—resolved the remaining mypy errors and regressions

Token cost:

“Total time on the clock: about 31 hours across four sessions. Total Codex token cost at the gpt-5.3-codex rates: about $44.”

The price is dominated by gpt-5.3-codex output tokens at a rate of $14 per million. That means 31 hours of autonomous work costs about as much as weeks of a ChatGPT Plus subscription.

What the agent did not do on its own:

• It did not write migration documentation for the team (Codex did not understand that this was part of the “migration”)
• It did not update configuration files for publishing with the new version of Pydantic
• It missed one production regression, which was caught only a day later

In other words, /goal did 95% of the work; the remaining 5% still has to be done by hand. That is normal for the current generation, and no reason not to use it.

Which Tasks Fit Long Overnight Runs#

The kinds of tasks where this approach offers the biggest gains:

• Low-level work where an iteration and check take minutes (compilation, running tests)
• Migrations with clear formal criteria (types, tests, lint)
• Benchmarks and optimizations with measurable results
• Documentation and changelogs with a clear structure

Claude /goal does the same just as well, but Codex is more often chosen for drivers because it checks files and logs itself rather than relying on an external judge.

How Much Does It Cost, and How Do You Avoid Burning Through Tokens Overnight?#

Figures from public accounts:

The main thing to understand: neither Claude Code nor Codex provides a hard “stop spending at $N” limit. There are three safeguards:

1. Subscription limits—Pro, Max, or Enterprise. On Anthropic’s Max plan ($100/month), a 14-hour overnight run fits within the weekly quota with room to spare
2. Text limit in the condition—write “or stop after 20 turns” directly in /goal. The Claude judge will read it and close the goal
3. Token limit in Codex—built-in mechanism that inserts budget_limit.md when tokens run out

What runs up the bill overnight:

• A vague criterion like “make it more convenient”—the agent will never stop, because the evaluator does not know what “better” means
• Access to external APIs without stubs—each retry costs tokens
• Long context—after 6.7M tokens, context compaction kicks in and some memory is lost

Read more about saving costs in the guides where Claude Code tokens go and how not to burn through your limits.

When NOT to Run /goal: 5 Situations#

OpenAI’s documentation explicitly says what NOT to do:

1. One-line edits—running /goal to rename a variable costs more than doing it by hand
2. Vague goals—“improve performance,” “make the code cleaner,” “make it more convenient.” The evaluator has no criterion, so the agent will spin forever
3. Production databases with user data—the agent could break a migration, and restoring from a backup costs more than any savings
4. Security changes—authentication, encryption, payment processing. A person needs to review every commit here
5. External APIs without stubs—every network failure costs tokens and is outside your control

What Should You Do If the Agent Gets Stuck?#

How to spot a loop quickly:

• The agent touches the same files for 3+ turns and returns them to their previous state
• Repeated errors appear in the log, errors it has already responded to
• The condition looks met to you, but the agent says “not met”
• Token use per turn is rising, but there is no progress in the code

What to do next:

• In Claude Code: /goal clear, then make the condition more specific
• In Codex: /goal pause, inspect the current thread, edit the condition with /goal edit, then /goal resume
• In both: check that the criterion is actually verifiable (a command returns exit 0 or produces specific output)

Often the cause of the loop is the task itself, not the agent. The condition “all tests pass” assumes that the tests can pass in the first place. If there is a deep architectural problem in the code, the agent will keep circling around the symptom.

“Done” Criteria: Task Discipline for /goal#

OpenAI states this rule plainly in its official Codex Cookbook:

Criterion templates that actually work:

The Combo row uses a combination: tests plus mypy plus lint. If even one check is still red, the goal is not closed. The evaluator has no chance to cheat.

Anti-patterns:

• “The code is better”
• “Usability has improved”
• “Performance has improved”
• “The documentation is complete”

The difference between “works” and “does not work” is verifiability. If a criterion cannot be checked with a command, it cannot be checked at all. This is also what OpenAI means by “long-horizon coherence”: an agent can think for a long time, but it cannot decide for itself what counts as “good enough.”

You can test the idea of “one prompt—one result” on a real project: set /goal, formulate a criterion, run it, and analyze what went wrong.

Get to know Ailoot.