OpenAI Codex Goal Mode Is Now GA — Multi-Hour Autonomous Coding Sessions

Pricing: Where Goal Mode Gets Expensive

Goal Mode is included with ChatGPT Plus ($20/month), Pro ($200/month), and Team ($25/user/month) subscriptions — but with rate limits that differ substantially by tier:

Plan	Goal Mode sessions per month	Max session duration	Concurrent sessions
ChatGPT Plus ($20/mo)	10	4 hours	1
ChatGPT Pro ($200/mo)	Unlimited	12 hours	3
ChatGPT Team ($25/user/mo)	25 per user	4 hours	1
API (pay-per-token)	Unlimited	No limit	Depends on rate limit tier

The Plus plan’s 10 sessions per month is the primary constraint for heavy users. A 4-hour session that covers a significant feature is one session. Run more than 10 meaningful autonomous tasks per month and you are on Plus hitting the ceiling regularly. For $200/month, Pro eliminates that ceiling but is a steep jump.

The API route exists for teams that need programmatic access: Goal Mode is available via the codex API endpoint with the goal_mode: true parameter. Pricing follows o4-mini token rates: $0.0011 input / $0.0044 output per 1K tokens. A full 4-hour autonomous session on a medium codebase consumes approximately 2–4 million tokens, costing $10–$20 per session via API.

Goal Mode vs. Claude Code Agent Mode

The honest comparison requires being specific about the use case, because these tools have genuinely different strengths:

Goal Mode advantages:

• True asynchronous operation — set it and close the browser. Claude Code agent mode requires an active terminal session.
• Built-in sandboxed execution — changes go to a working copy, not your local files, until you approve. Claude Code writes to your actual working directory by default.
• Role plugins provide task-specific behavior tuning without manual system prompt engineering.
• Notification-based completion fits into a “delegate and review” workflow better than interactive terminal sessions.

Claude Code agent mode advantages:

• 88.6% SWE-bench score (Opus 4.8) versus o4-mini’s 68.4%. For complex engineering problems that require genuine reasoning, the capability gap is real.
• 1M token context window. Goal Mode effectively operates on the files it identifies as relevant — large monorepos with cross-cutting dependencies are harder for it to handle holistically.
• MCP ecosystem. Claude Code can invoke external tools (databases, APIs, documentation) mid-session. Codex Goal Mode operates in a more sandboxed environment.
• Flat-rate interactive pricing. For heavy users, Claude Code Max at $100/month flat is cheaper than ChatGPT Pro at $200/month.

The honest split: Goal Mode is better for well-defined, bounded tasks where you want true async operation and do not need the highest-capability model. RefactorBot running a migration, TestWriter pushing coverage, or DocBot generating docs are legitimate use cases where o4-mini’s lower capability does not matter because the task is mechanical. Claude Code agent mode is better for complex feature work, architecture-level reasoning, and tasks that require integrating context across a large codebase.

Real Examples from the Beta

Three representative cases from the closed beta reports (sourced from OpenAI’s blog post and beta participant threads):

Case 1: Django to FastAPI migration (7.2 hours). A developer set a goal to migrate a 15,000-line Django REST API to FastAPI. Goal Mode used MigrationGuide plugin, ran for 7.2 hours across two sessions, and completed 94% of the migration — surfacing 8 blockers where business logic required human decisions about async patterns. The developer reviewed and resolved blockers in 45 minutes total. Estimated manual equivalent: 3 days.

Case 2: Generating test suite for a payment module (3.1 hours). TestWriter plugin, payment module with zero existing tests, 87% coverage achieved in 3.1 hours. The developer noted that 12% of the generated tests had incorrect assertions about edge cases that required manual correction. Coverage was real; assertion quality required review.

Case 3: Security audit on a Node.js API (4 hours, timed out). SecurityAuditor ran for 4 hours (Plus plan limit) and surfaced 23 potential vulnerabilities before timeout. The developer reported 19 of 23 were legitimate issues, 3 were false positives, and 1 was a valid issue it did not catch. Not a clean pass, but 19 real vulnerabilities found autonomously is a strong result for a single session.

How to Start a Goal Mode Session

The workflow from the ChatGPT interface:

1. Open ChatGPT and select Codex from the left sidebar
2. Connect your repository via GitHub OAuth (first time only)
3. Click New Goal
4. Select a role plugin or choose “Custom” for free-form objectives
5. Write your goal statement — be specific about the target state, not the steps
6. Review the generated plan and approve or edit
7. Click Start Goal and optionally set a notification preference

Goal statements that work well: “Add Redis caching to all database queries in the user service, with TTLs appropriate to each query’s data volatility, and add integration tests.” Goal statements that fail: “Make the app faster.” The more specific the target state, the better the plan quality.

Templates for writing effective Goal Mode prompts for different engineering tasks are available in the developer toolkit at wowhow.cloud.

People Also Ask

What is OpenAI Codex Goal Mode?

Goal Mode is a feature in OpenAI Codex that lets developers set a persistent software objective — like “migrate this API” or “generate tests for this module” — and have Codex autonomously plan, implement, test, and iterate until the goal is achieved or it encounters a blocker. It runs asynchronously for up to 4 hours (Plus) or 12 hours (Pro) without requiring active user input.

How much does Codex Goal Mode cost?

Goal Mode is included with ChatGPT Plus ($20/month, 10 sessions/month limit), Pro ($200/month, unlimited), and Team ($25/user/month, 25 sessions/user/month). Via API, sessions cost approximately $10–$20 per 4-hour session at o4-mini token rates. Plus plan users hitting the 10-session limit need to either upgrade to Pro or use the API for additional sessions.

Is Goal Mode better than Claude Code for autonomous coding?

It depends on the task. Goal Mode’s true asynchronous operation and sandboxed execution are genuine advantages for delegated, well-defined tasks. Claude Code agent mode has a higher SWE-bench score (88.6% vs 68.4% for o4-mini), a 1M token context window, and the MCP ecosystem for complex feature work. The tools are complementary rather than competitive for most heavy users.

What does a Codex Goal Mode session actually output?

At session end, Codex produces: a git diff of all changes, a test run summary, a log of every step taken, and a list of any unresolved blockers. Changes are held in a working copy until you review and approve the merge. You never get silent commits to your main branch.