OpenAI’s Codex CLI 0.128.0 introduced /goal on April 30, 2026, implementing persistent autonomous workflows that keep agents running until tasks complete — potentially for days — without requiring manual intervention between turns.
Built by Eric Traut, creator of the Pyright type checker, the feature represents Codex’s official implementation of Ralph loops, the community-developed pattern where bash scripts repeatedly invoke AI agents until goals are achieved. With GPT-5.5 powering the backend, developers can now instruct Codex to build OS kernels, audit entire codebases, or optimize database schemas across multi-day sessions while maintaining goal state across turns instead of starting fresh each time.
What /goal Actually Does
The /goal command creates persistent workflows where Codex evaluates whether a stated objective has been completed, then automatically continues work across turns until either the goal is satisfied or the configured token budget exhausts. According to Simon Willison’s analysis of the implementation, the feature operates primarily through two automatically injected prompts: goals/continuation.md and goals/budget_limit.md, which appear at the end of each turn to maintain context and enforce spending limits.
To enable /goal, users edit their config.toml file, locate the [features] section, and add goals = true. Once activated, developers can set long-running objectives like "implement subscription system with full test coverage" or "audit codebase for security vulnerabilities and generate fix PRs." Codex loops autonomously, making incremental progress, running tests, committing changes, and continuing until it determines the goal is complete or resources run out.
The technical distinction from earlier Ralph loop implementations is that /goal maintains state natively within Codex rather than relying on external bash scripts to restart sessions. Community-built tools like CodexPotter and ralphex required wrapping Codex invocations in while loops that reinitialize the agent each cycle, using Git commits as memory between restarts. Codex’s native /goal feature preserves context across turns internally, reducing overhead and improving coherence on multi-step tasks.
Why Ralph Loops Became Infrastructure
Ralph loops emerged in early 2025 as a community pattern for preventing “context rot”—the phenomenon where AI agents become less effective as sessions lengthen and token windows fill. Named after Ralph Wiggum from The Simpsons for being “ignorant, persistent, and optimistic,” the pattern involves bash scripts that repeatedly invoke agents with the same goal, ignoring errors, until success.
The workflow typically looked like this: create a design document defining the goal, requirements, and acceptance criteria; write a shell script that loops codex exec with –dangerously-bypass-approvals-and-sandbox flags; let the script run for hours or days, with Git serving as shared memory between restarts; manually review commits and test results after completion. Each iteration created a clean session, preventing context accumulation but also losing nuanced understanding built during previous passes.
Geoff Huntley, who popularized Ralph loops for Claude Code, described them as useful when tasks are large enough that context rot becomes a real risk, when you want clean git diffs after every iteration for auditability, or when working with agents that benefit from session resets. The pattern spread across Claude Code, Codex, and GitHub Copilot CLI communities because it worked—autonomous multi-hour coding sessions became practical despite model limitations around long-running context.
OpenAI integrating /goal directly into Codex CLI signals that the Ralph loop workflow graduated from community hack to production feature. Rather than developers writing custom bash wrappers, Codex now provides native support for the same continuous execution pattern with better context preservation and resource management.
What Multi-Day Autonomous Sessions Enable
With GPT-5.5‘s improved reasoning and tool-use consistency, /goal unlocks tasks previously requiring constant human supervision. Building an OS kernel from specifications becomes feasible—Codex can research kernel architecture, design memory management systems, implement schedulers, write device drivers, debug boot sequences, and iterate on performance optimizations across days of autonomous work.
Critical bug discovery in large codebases shifts from manual code review to agent-driven audits. Developers can task Codex with reading every file, identifying security vulnerabilities, race conditions, and logic errors, then generating comprehensive audit reports with line numbers and code snippets. The d4b.dev guide to Ralph audit loops demonstrates this pattern: agents run read-only analyses, document findings extensively, and provide external references validating concerns against official documentation.
Database schema optimization becomes an autonomous workflow. Codex can analyze query patterns, identify performance bottlenecks, design index strategies, test migrations against production-scale datasets, and validate that optimizations don’t introduce regressions—all without human intervention between analysis and implementation phases.
The key enabler is GPT-5.5’s ability to hold original intent across 20-30 step tasks. Earlier models exhibited drift—by step five, they’d start interpreting goals loosely, introducing unintended changes or losing focus on acceptance criteria. GPT-5.5’s stronger instruction-following reduces this problem significantly, making multi-day autonomous sessions viable where previous models would have wandered off-target.
The Resource Management Problem
Unbounded Ralph loops consume tokens at alarming rates. Each iteration is an API call. An unguarded loop running for 48 hours can quietly burn through thousands of dollars in compute costs with no guarantee of completing the goal. Codex’s /goal implementation addresses this through configurable token budgets specified in goals/budget_limit.md, but the fundamental challenge remains: autonomous agents optimizing for goal completion don’t naturally optimize for cost efficiency.
The CodexPotter documentation recommends starting with small iteration counts when testing new workflows, reviewing commits before merging, and establishing clear stopping conditions. The danger isn’t just cost—it’s drift in a different form. An agent stuck in a logic loop might commit broken code repeatedly, each iteration making the codebase worse while technically making “progress” toward a misunderstood goal.
Production-grade implementations require guardrails. The ralphex extended Ralph loop project demonstrates one approach: implement commit hooks that run linters and tests before each commit; define validation commands in the goal document that must pass before marking tasks complete; use multi-agent review where separate instances audit work before acceptance; track phase completion explicitly rather than relying on agent self-evaluation.
When Native /goal Beats External Loops
Codex’s built-in /goal feature excels at single-pass work where the agent can hold context for the full task without session resets. Complex refactors benefiting from understanding architectural decisions made in previous steps work better with continuous context than with Git-based memory between restarts.
External Ralph loops remain superior when the task is large enough that context rot becomes unavoidable despite GPT-5.5’s improvements, when you need clean git diffs after every iteration for strict auditability, or when you want explicit control over the restart cycle rather than trusting Codex’s internal continuation logic.
The hybrid approach—using GPT-5.3-Codex or GPT-5.5 for comprehensive planning, then switching to GPT-5.3-Codex-Spark (1,200+ tokens/second) for rapid implementation—represents where the ecosystem is heading. Architecture and reasoning happen at deliberate speeds with full context windows. Execution happens at machine speed with focused, narrow contexts. The /goal feature can orchestrate this model switching internally rather than requiring external scripts to manage it.
What Gets Overlooked in the Enthusiasm
Multi-day autonomous coding sounds transformative until you consider what happens when goals are poorly specified. An agent tasked with “optimize performance” might profile the application, identify database queries as bottlenecks, replace the SQL database with Redis, break every transaction-dependent feature, and mark the goal complete because query latency decreased. Technically correct. Contextually disastrous.
The quality of autonomous work depends entirely on goal specification rigor. Design documents need explicit acceptance criteria, non-goals sections defining what shouldn’t change, and validation commands that test actual requirements rather than implementation details. The ralphex workflow addresses this through interactive planning sessions where Claude asks clarifying questions, explores the codebase, and generates structured plans before implementation begins.
Even with perfect specifications, autonomous agents make architectural decisions humans might regret. Choosing caching backends, authentication methods, and third-party dependencies based on what seems technically sound at implementation time can create long-term maintenance burdens when those choices don’t align with broader system architecture or team expertise.
The multi-agent review pattern—having separate instances audit quality, implementation correctness, testing coverage, over-engineering, and documentation—catches some of these issues but introduces new costs. Running five parallel review agents after every implementation phase multiplies token consumption. The ralphex approach of using GPT-5 for independent review alongside Claude Code provides a second perspective but also doubles model invocations.
Where This Goes
Codex /goal represents infrastructure for a development workflow where agents handle increasing portions of the software lifecycle autonomously. Planning, implementation, testing, documentation, and review all become delegatable to systems that run continuously until completion rather than requiring developer presence for every decision.
The immediate beneficiaries are solo developers and small teams where developer time is the primary constraint. Setting a goal Friday afternoon and reviewing completed, tested code Monday morning shifts the bottleneck from implementation speed to specification quality. The challenge becomes defining problems precisely enough that agents solve the right thing, not just something.
For larger teams, the model looks different. Senior engineers write specifications, autonomous agents implement features, junior engineers review and refine agent output, and architects ensure coherence across agent-generated components. This workflow assumes agents become reliable enough that reviewing their work requires less effort than writing it from scratch—a threshold GPT-5.5 approaches for well-defined tasks but hasn’t definitively crossed for complex, ambiguous problems.
The risk is building systems where nobody fully understands how individual components work because agents implemented them autonomously across multi-day sessions while developers focused elsewhere. Code review catches bugs and logic errors, but it doesn’t necessarily impart the deep understanding that comes from writing code yourself. Whether that trade-off makes sense depends on whether understanding implementation details matters more than shipping features quickly.
OpenAI chose to build /goal natively because Ralph loops were happening anyway through community tools. Better to provide official support with proper resource management than have developers run unguarded bash scripts burning tokens. That’s pragmatic infrastructure development. Whether it’s wise infrastructure development depends on whether autonomous multi-day coding sessions create more value than risk at current model capability levels. We’re about to find out.
Follow us on Bluesky, LinkedIn, X, and Telegram to Get Instant Updates
