Codex Just Became THE BEST Long Running Agentic Harness

하이라이트

• Codex Goals enables autonomous task execution for hours without manual intervention or additional orchestration layers.

• Enabling the experimental feature requires adding 'features' and 'goals = true' to the config.toml file or prompting the AI to do it.

• Integrated budget and continuation markdown files allow the system to wrap up turns gracefully and provide reports when hitting token caps.

• The system supports DALL-E 3 image generation directly within the agentic loop to create unique visual assets for software projects.

• Successful goal execution requires a highly specific 'plan mode' session to define quantifiable verification criteria like Playwright test scripts.

• Complex projects require starting a new chat thread for each subsequent goal pass to maintain session and goal integrity.

타임라인

1. 00:00 - 01:34

   Experimental Goals Feature Setup

   This new capability aims to simplify the execution of long-running tasks by removing the need for third-party scaffolding. Users can modify the configuration directly in VS Code or request the AI to enable the settings autonomously. While experimental, it offers a more streamlined alternative to external tools like Claude Code for persistent agentic workflows.

   • Codex Goals functions as a sophisticated, integrated version of the Read-Act-Loop-File (RALF) pattern.
   • Manual configuration involves adding specific feature flags to the open-config.toml file within the desktop app.
   • The feature operates through a single /goal slash command in both the desktop application and CLI.
2. 01:35 - 06:53

   RALF Loops vs. Native Goals Architecture

   Standard RALF loops provide a basic autonomous cycle but lack sophisticated error handling or budget management. Codex Goals introduces a graceful shutdown mechanism that generates a final report of completed work when usage limits are reached. This native integration handles deliverable auditing and status updates without requiring the 40-minute setup times associated with other orchestration layers.

   • Traditional RALF loops rely on a bash script to cycle between prompt.md and state.md files to track progress.
   • Codex Goals uses invisible continuation and budget limit files to handle usage limits and crashes.
   • The system follows four distinct logic paths at the end of each turn based on remaining work and token availability.
3. 06:54 - 10:32

   Plan Mode and Verification Criteria

   Before starting a goal, the system must define the exact end state to avoid drift during long-running sessions. The verification plan for a game project includes running npm build, checking for non-blank canvases, and simulating keyboard events to force damage and check health changes. This specific criteria allows the agent to audit its own work before declaring a goal complete.

   • Transitioning from plan mode to goal mode ensures the agent has a specific and quantifiable objective.
   • Automated Playwright scripts serve as the primary verification method for confirming software functionality.
   • Fuzzy or non-specific prompts result in mediocre or half-baked project outcomes.
4. 10:33 - 14:38

   Autonomous Game Development and Asset Generation

   In a real-world demo, the agent created 11 unique assets including drone sprites, energy cores, and background tiles for a 2D combat game. The integration of DALL-E 3 allows the agent to handle visual design tasks that typically require external MCPs or manual intervention in other environments. The resulting product is a functional canvas-based game with spawning enemies and scoring systems.

   • Codex leverages OpenAI's image generation models to create unique bitmap assets with alpha cutouts during the build process.
   • The desktop app displays image generation and terminal output inline for easier progress monitoring.
   • Initial game builds can be completed in approximately 30 minutes of autonomous runtime.
5. 14:39 - 17:12

   Iterative Development and Goal Threading

   The second development pass added hit-point systems, enemy return-fire, and UI widgets for boss signals in 15 minutes. Because each goal run is tied to a specific session thread, opening a new chat is necessary for iterative improvements on the same codebase. This workflow demonstrates how autonomous agents can evolve a project through successive, targeted objectives.

   • Subsequent project iterations require copying the new plan into a fresh chat thread to reset the goal session.
   • Multi-pass development allows for adding complex features like laser combat systems and boss phase triggers.
   • Combining Claude Code for planning and Codex for execution maximizes the strengths of different AI models.