Codex, Claude Code, Hermes Launch /goal Together – Coincidence or Autonomy Tipping Point?

OpenAI Codex CLI

Release date : 2026‑04‑30 (Codex v0.128.0)

Five‑layer architecture

Persistence layer : SQLite stores goal state with fields goal_id, objective, status, token_budget, tokens_used, time_used_seconds. Status values are active, paused, budget_limited, complete.

API layer : JSON‑RPC methods thread/goal/set, thread/goal/get, thread/goal/clear plus notification events thread/goal/updated and thread/goal/cleared.

Model‑tool layer : Tools create_goal (create), update_goal (mark complete, callable only by the action model), get_goal (query). The model cannot pause or resume goals; those are system‑level controls.

Core runtime : Event‑driven lifecycle management, automatic token/time accounting, budget‑exhaustion pause, and a continuation‑suppression mechanism to prevent infinite loops.

TUI interface : Sub‑commands /goal, /goal pause, /goal resume, /goal clear with a status bar showing usage metrics.

Goal template

/goal <objective>
Scope: <file boundary>
Constraints:
- <hard constraint 1>
- <hard constraint 2>
Done when:
1. <verifiable output 1>
2. <verifiable output 2>
Stop if:
- <mechanical stop condition 1>
- <mechanical stop condition 2>
Use a token budget of <N> tokens.

The template requires machine‑verifiable criteria such as passing ruff check, all tests green, and coverage ≥ 80%.

Budget governance

Each goal can specify a token budget; the system continuously tracks consumption and triggers a soft stop when the limit is approached, addressing uncontrolled token usage.

Claude Code

Release date : 2026‑05‑11 (Claude Code v2.1.139)

Evaluation model mechanism

After each turn of the work model, the system sends the goal conditions and current dialogue context to a small, fast model (often Claude Haiku). The judgment model returns a yes/no answer with a brief rationale. A “no” answer causes the next turn to start automatically; a “yes” answer stops execution.

User experience

/goal <condition>

: set goal and completion criteria. /goal: view current goal status, including runtime, turn count, token usage, and the latest judgment‑model reason. /goal clear: clear the goal.

Goal conditions may be up to 4,000 characters and must contain three elements: a measurable end state, a checkable method, and a truly important constraint.

Autonomous mode comparison

/goal

– condition‑driven; stops when the condition is satisfied. Suitable for tasks with clear completion criteria. /loop – time‑driven; repeats on a timer. Suitable for continuous monitoring or periodic polling.

Stop hooks – event‑driven; triggered by scripts or prompts. Suitable for custom stop logic.

Hermes Agent

Release date : 2026‑05‑07 (Hermes v0.13.0)

Cross‑platform persistence

Goal state is stored in SessionDB.state_meta under the key goal:<session_id>. This enables:

Goal creation in the CLI, progress checking in Telegram, and resumption in Discord.

Goals survive session disconnects; /resume or /continue restores the exact state (active/paused/done).

Supported platforms include CLI, Telegram, Discord, Slack, Matrix, Signal, WhatsApp, SMS, iMessage, Webhook, API server, and Web Dashboard.

Judgment model fault tolerance

The goal_judge task uses a “fail‑open” semantics: if the model errors, the default decision is to continue, preventing the agent from stalling due to a broken judge.

Turn budget and false‑positive handling

Hermes sets a default budget of 20 continuation turns; exceeding this pauses the goal, which can be reset with /goal resume. The judgment model marks a goal as done only when it explicitly confirms completion, delivers a tangible artifact, or the goal is truly impossible, providing a double‑layer safeguard: conservative judgments reduce false‑positives, the turn budget catches false‑negatives.

Configurable judgment model

Users can configure goal_judge to use a cheap, fast model to lower cost. For a goal requiring many turns, using an expensive model for every judgment would be prohibitive.

Horizontal comparison

Goal storage : Codex – SQLite (thread‑level); Claude – session memory; Hermes – SessionDB (agent‑level).

Judgment mechanism : Codex – update_goal tool; Claude – independent small model (Haiku‑level); Hermes – configurable goal_judge.

Budget control : Codex – token + time dual budget; Claude – none explicit; Hermes – turn budget (default 20).

Cross‑platform support : Codex – CLI only; Claude – CLI/IDE/Slack; Hermes – 12+ platforms.

Cross‑session persistence : Codex – none; Claude – resumable via /resume; Hermes – fully persistent.

Fault tolerance : Codex – continuation suppression; Claude – automatic stop; Hermes – fail‑open.

Architecture complexity : Codex – five‑layer; Claude – lightweight; Hermes – medium.

Typical scenarios : Codex – large refactoring or migration; Claude – coding sessions; Hermes – persistent agent tasks.

Why /goal now?

1. From “prompt engineering” to “goal engineering”

Developers must now define machine‑verifiable goals rather than crafting single‑sentence prompts. The shift requires specifying what constitutes completion.

2. Engineering autonomous loops

Community hacks such as “Ralph loop” enable repeated execution but lack unified stop conditions, budget control, and state management. /goal makes stop conditions first‑class, exposes configurable budgets, and provides queryable state.

3. Reliability as a prerequisite for agents

Agents that need a human to say “continue” are not truly autonomous. /goal gives agents the ability to decide “I am done”, addressing the “half‑way abandonment” problem.

Conclusion

/goal

marks the transition of AI coding assistants from conversational tools to autonomous agents. Codex provides a rigorously engineered five‑layer system with fine‑grained token and time budgeting. Claude Code offers a lightweight architecture that separates work and judgment models. Hermes adds cross‑platform, cross‑session persistence and a configurable judgment model with fail‑open fault tolerance. All three converge on the same direction: AI will not only write code but will achieve defined, verifiable goals.

Sources: Codex /goal documentation; Claude Code /goal documentation; Hermes Goals documentation; Codex /goal implementation analysis; Goalcraft; Harness Engineering Overview; Hermes Agent Overview; Building Effective Agents