How Claude Code's /goals Prevents AI Agents from Quitting Too Early

AI coding agents often halt prematurely, mistaking partial progress for task completion. This leads to missed steps, broken builds, and costly rework. Anthropic's /goals command in Claude Code tackles this by separating the agent that executes tasks from the one that decides when the job is truly done. Below, we explore how it works, why it matters, and how it stacks up against alternatives.

What problem does Claude Code's /goals solve?

Production AI pipelines frequently fail not because models lack capability, but because the agent itself decides it's finished before fulfilling the actual requirements. For example, a code migration agent might exit after seeing a green pipeline, even though several files were never compiled. Traditional agent loops rely on the same model to both execute and evaluate—leading to overconfidence. Claude Code's /goals prevents this by introducing a dedicated evaluation model that runs independently after every step. The executing model works iteratively—reading files, running commands, editing code—while the evaluator checks if the user-defined goal is met. Only when the evaluator confirms completion does the agent stop. This eliminates the conflict of interest where a model judges its own work, reducing costly premature exits.

How does /goals separate task execution from evaluation?

The key innovation is a two-model split. One model (the agent) focuses solely on performing the task—stepping through actions like reading files, running commands, and editing code. After each action, a separate evaluator model (defaulting to Haiku) reviews the progress against the user-defined goal. This evaluator makes only two decisions: is the goal met, or not? If not, the agent continues its loop. If met, it logs the condition, clears the goal, and signals completion. By decoupling execution from judgment, /goals ensures the agent cannot fool itself into early termination. The developer sets the goal as a clear condition in natural language (e.g., /goal all tests in test/auth pass, and the lint step is clean), and the system enforces it objectively.

How does the evaluation loop work step by step?

After the user defines a goal using the /goals command, Claude Code begins its standard agent loop: turn by turn, it reads files, runs commands, edits code, and attempts to complete the task. Crucially, after every step where the agent thinks it's done, the evaluator model (by default Haiku) steps in. The evaluator checks the current state against the goal condition. If the condition is not satisfied, the agent keeps running—it gets another turn. If the condition is satisfied, the evaluator logs the achieved condition to the conversation transcript, clears the goal, and the process ends. This stops repeated evaluations and prevents infinite loops. Developers can fine-tune the evaluator's strictness by adjusting the goal prompt (e.g., requesting longer or shorter runs). The entire loop is transparent, with each evaluation recorded, so teams can audit decisions later.

How does /goals compare to solutions from OpenAI, LangChain, and Google?

All three vendors recognized the same roadblock: agents halting prematurely. But their approaches differ. OpenAI leaves the loop unchanged—the model decides when it's done—but lets users attach custom evaluators. LangGraph and Google's Agent Development Kit (ADK) support independent evaluation, but developers must manually define the critic node, write termination logic, and configure observability. In contrast, Claude Code's /goals bakes the evaluator into the default loop. The developer simply sets a goal prompt; the system handles the rest. Google ADK's LoopAgent requires explicit architecture. Anthropic's approach reduces boilerplate and ensures consistent evaluation without extra effort. This makes /goals particularly attractive for teams that want reliable termination without complex setup.

Why does Anthropic use Haiku as the default evaluator model?

The evaluator model handles only two decisions: is the goal met, or not? Because of this simplicity, a smaller, faster model like Haiku works perfectly. It doesn't need the full reasoning power of a larger model—just reliable classification against a clear condition. Using Haiku reduces latency and cost in the evaluation loop. If a developer wants stricter or looser evaluation, they can adjust the goal prompt to influence Haiku's judgment. For instance, adding more detail to the condition can make the evaluator run longer. Anthropic notes that Haiku's lightweight nature also means it can run more frequently (after every potential exit) without bogging down the overall process. This efficiency is a deliberate design choice: the heavy lifting is done by the execution model, while the evaluator is lean and fast.

What conditions make /goals most effective?

Anthropic's documentation highlights that the most successful goals share characteristics. They should have one measurable end state—a single, unambiguous condition that can be checked objectively (e.g., “all tests pass”). They should rely on programmatic signals (exit codes, test results) rather than subjective assessment. The goal should be phrased positively (“do this”) rather than negatively (“don't do that”). Finally, predictable side effects help: the evaluator should know exactly what outputs to expect when the goal is met. For example, specifying that a lint step must produce zero errors, or that a build artifact must exist. By keeping goals clear and checkable, developers maximize the reliability of the evaluation loop.

What are the benefits of using /goals over third-party observability?

With /goals, Anthropic notes there is no need for a third-party observability platform, no custom logging setup, and less reliance on post-mortem reconstruction. The evaluator logs each condition check directly into the agent conversation transcript, providing a built-in audit trail. This simplifies the tech stack and reduces overhead. However, enterprises that already use monitoring tools can continue to run them alongside Claude Code without conflict. The key advantage is that /goals catches premature exits in real time rather than after the fact. Instead of discovering a missed compilation through external dashboards days later, the agent is forced to complete the work before it halts. This saves debugging time and prevents cascading failures in production pipelines.

Can /goals be integrated with existing enterprise monitoring?

Yes. While /goals removes the necessity for third-party observability, Anthropic explicitly states that enterprises are free to continue using monitoring platforms alongside Claude Code. The /goals feature doesn't interfere with external logs, metrics, or tracing tools. Teams can still deploy their preferred observability stack (e.g., Datadog, Prometheus) to gain broader visibility into agent behavior. In fact, combining /goals with external monitoring can provide both proactive enforcement (via the evaluator) and retrospective analysis (via dashboards). This flexibility allows organizations to adopt the feature gradually, without disrupting existing workflows. The built-in transcript logging from /goals supplements—not replaces—enterprise monitoring, giving teams optional redundancy.