Every AI coding agent eventually runs into the same fundamental architectural wall: the task takes longer than a single turn, and as the human developer driving it, you have better things to do than sit there hitting enter for six hours. Whether you are performing complex codebase migrations, executing large-scale refactors, hunting down notoriously flaky tests, or maintaining a pull request until it hits a green status, you are no longer dealing with simple one-shot prompts. You are dealing with campaigns. By 2026, both Anthropic and OpenAI have integrated native answers to this challenge. Claude Code features distinct mechanisms known as /loop and /goal, while the OpenAI Codex CLI employs its own /goal implementation. While they all aim to keep the agent operational without constant human intervention, their decision-making logic for when to trigger the next turn differs significantly. Misunderstanding these nuances will result in either wasted API credits or an agent that prematurely terminates its work cycle.
The Problem with One-Turn Paradigms
In standard agentic workflows, the interaction is a closed round trip: you submit a prompt, the agent parses files, executes CLI commands, modifies code, and relinquishes control. This model is ideal for atomic tasks like write a null check or explain this utility function. However, this paradigm collapses under the weight of multi-hour or multi-day tasks. Historically, the developer workaround involved manual labor: re-pasting continue commands every few minutes or writing custom shell scripts to wrap the CLI. Modern AI tools have integrated these capabilities directly into the binary, but they have taken divergent paths to reach the same goal.
Claude Code’s /loop: Time-Driven Automation
The /loop command acts as a built-in scheduler for repeating tasks within your current active session. It is explicitly session-scoped, meaning the task persists as long as the conversation is alive.
There are three primary ways to leverage this functionality:
-
Fixed Cadence: You provide an interval such as
/loop 5m check deployment status. The system maps this to a cron-like schedule. Seconds are rounded to the nearest minute, ensuring the agent triggers according to your defined heartbeat. -
Self-Paced Polling: By omitting the interval, you instruct Claude to manage its own cadence. After every iteration, the agent analyzes the context and determines if it should wait a minute or up to an hour based on the observed activity. Often, it will favor the
Monitortool to stream output rather than performing expensive prompt re-runs. -
Maintenance Mode: By calling
/loopwithout arguments, you trigger a default routine that manages PR comments, CI failures, and branch health. You can customize this behavior globally via.claude/loop.mdfiles.
Claude Code’s /goal: Condition-Driven Automation
Introduced in version 2.1.139, the /goal command shifts the focus from time intervals to state-based completion. You define a success condition, and after each turn, a secondary, lightweight model (typically Haiku) evaluates the conversation history against your goal.
- Logic: If the evaluator says "no," the agent performs another turn. If "yes," the goal is marked complete.
- Implementation: It does not replace the permission layer; it simply acts as a persistent hook that evaluates progress. It works exceptionally well for tasks like running test suites until they pass.
Codex /goal: Multi-Day Objectives
OpenAI’s Codex CLI approach to goals is designed for resilience. It is meant to handle tasks that span multiple days. Once enabled via configuration (or the --enable goals flag), the agent operates through specific states: pursuing, paused, achieved, and budget-limited.
- Autonomy vs. Review: As with all autonomous agents, increased freedom necessitates increased oversight. Always treat the final diff as a draft from a junior engineer.
Practical Implementation: A Minimal Example
To test this, create a directory with a buggy function and a corresponding test suite. In the case of Node.js with Jest, you can simply run:
/goal `npx jest` exits 0
The agent will parse the test failure, modify the source code, and repeatedly attempt to run the command until the test suite signals an exit code of 0. This demonstrates the power of condition-based loops compared to standard timed polling.
Technical Considerations and Edge Cases
When deploying agents for hours or days, consider the following:
- Token Budgeting: Always be mindful of the cost. A runaway loop can consume a significant amount of your API budget if the condition is poorly formed or the environment changes in a way that prevents resolution.
- Environment Stability: If your agent depends on external APIs or database states, ensure your network connectivity and authentication tokens are persistent. For long-running tasks, utilizing a headless server or a remote persistent machine is superior to a local laptop setup.
- Error Handling: A well-defined goal should include constraints. If your condition is "fix all errors," ensure you also include a constraint on "max number of attempts" to avoid infinite loops in a hallucinating agent.
-
Tool Reliability: When using tools like
MonitororScheduleWakeup, understand that these rely on specific terminal integration. Ensure your shell environment supports background streaming if you are using advanced features.
Production Readiness
Moving from local experimentation to long-horizon production tasks requires a shift in mindset. You are not just writing code; you are maintaining a process. Use the --verbose flag to debug why an agent might be stuck in a loop. When the agent reports "unmet" status, it usually means it has reached a terminal error that requires human intervention. Do not treat these tools as "set it and forget it" black boxes. They are best viewed as high-performance assistants that require a final manual review of every commit they generate.
Conclusion
Choosing between a timer-based /loop and a condition-based /goal is a matter of knowing your finish line. If the finish line is state-based (like passing tests), use a condition. If the task requires periodic polling (like waiting for a long-running CI process), use a timer. Combine these with robust logging and manual PR review, and you can significantly reclaim your time while keeping your development velocity high.
Top comments (0)