DEV Community

Cover image for OpenAI’s new Codex Mac app is an agent “command center” (and it’s lighting up the devtool wars)
Sivaram
Sivaram

Posted on

OpenAI’s new Codex Mac app is an agent “command center” (and it’s lighting up the devtool wars)

#ai #devtools #productivity #openai

TL;DR

OpenAI just shipped a standalone Codex app for macOS that’s less “AI in my editor” and more orchestration layer for multiple coding agents. For a limited time it’s available even on ChatGPT Free and Go, and OpenAI is doubling Codex rate limits for Plus/Pro/Business/Enterprise/Edu. The vibe: a desktop command center for running parallel agent threads across projects, reviewing diffs, committing, opening PRs, and scheduling automations.

If you’ve been juggling Cursor, Claude Code, and an army of terminal tabs, this is OpenAI taking a very direct swing at that workflow.

What shipped (and why it matters)

macOS-only (for now)

The Codex app is explicitly introduced as a macOS desktop app, with a download link for macOS in OpenAI’s announcement. The press coverage also frames it as launching for Apple computers first.

That’s a practical constraint (Windows/Linux folks: welcome to the waiting room), but also a signal: OpenAI is leaning into the “devs on Macs” reality the same way many devtools companies do.

Sources:

Included for all tiers (temporarily)

OpenAI says that for a limited time, Codex is included with ChatGPT Free and Go. That’s unusual: “agentic coding” is usually paywalled hard, because compute is not cheap and code agents tend to be token-hungry.

This move feels like OpenAI trying to compress adoption time: let everyone try the workflow, then let the limits/pricing do the rest later.

Source:

Doubled rate limits for paid subscribers

OpenAI also says it’s doubling Codex rate limits on Plus, Pro, Business, Enterprise, and Edu plans—and those higher limits apply everywhere you use Codex: the app, CLI, IDE, and cloud.

This is the kind of change that actually matters in real use: tools aren’t “slow” because models are dumb; they’re slow because you hit limits, wait, context-switch, and lose momentum.

Source:

Codex app: the “command center for agents” idea

OpenAI’s framing is blunt: the hard problem shifted from “what can agents do” to “how do humans direct, supervise, and collaborate with multiple agents at scale,” and IDEs + terminal workflows weren’t designed for that.

The app is positioned as the missing UI for:

  • multiple agents running in parallel
  • long-running work
  • supervision + review
  • project-level context
  • repeatable workflows (“skills”)
  • scheduled background work (“automations”)

Source:

Features (from docs + announcement)

Below are the pieces that keep showing up in both OpenAI’s write-up and early hands-on reports.

1) Threads organized by project (parallel agents)

Agents run in separate threads, grouped by project, so you can jump between tasks without losing context. You can review changes inside the thread, comment on the diff, and open the work in your editor for manual edits.

Source:

2) Built-in git tooling (+ review/commit/PR ergonomics)

The app is built around shipping code, not just suggesting it:

  • review diffs
  • commit changes
  • push / open PR flows (as shown in early screenshots and creator walkthroughs)

This is a meaningful differentiation vs “chat panel in an IDE”: shipping is a workflow, not a prompt.

Source:

3) Worktrees support

OpenAI says the app includes built-in worktree support so multiple agents can work on the same repo without conflicts. Each agent operates on an isolated copy, letting you explore paths without wrecking your local git state.

Worth noting: “worktrees” is loaded terminology. OpenAI uses the term broadly; some power users describe the UX as closer to “copy + sync-back” in practice. Either way, the intent is isolation per task/agent.

Source:

4) Skills (workflow bundles)

Skills are the big “agents doing real work” story. OpenAI describes skills as bundles of instructions, resources, and scripts so Codex can connect to tools and execute workflows reliably. The app includes a UI to create/manage skills, and skills can be used across app/CLI/IDE, and even checked into a repo for team usage.

OpenAI highlights skills for:

  • Figma → production UI
  • Linear triage
  • deployments (Cloudflare/Netlify/Render/Vercel)
  • image generation
  • reading/writing docs (PDF, spreadsheets, docx)
  • up-to-date API reference

Source:

5) Automations (scheduled background tasks)

Automations let Codex run tasks on a schedule and drop results into a review queue. The examples OpenAI gives are very “real engineering chores”:

  • daily issue triage
  • summarizing CI failures
  • daily release briefs
  • bug checks

Source:

6) Personality switching

Codex supports a /personality command: choose between a terse pragmatic style and a more conversational one, without changing capability.

Source:

7) Sandbox/security controls

Running an agent with write access locally is terrifying if you’ve ever watched one hallucinate a command. ZDNET describes the app’s sandbox model: restricting folder writes and permissioned network access, with approval levels.

Treat ZDNET as secondary reporting, but it aligns with OpenAI’s broader security messaging.

Source:

The devtool war angle: Codex vs Cursor vs Claude Code

Let’s be honest: “AI coding tools” is no longer one category. There are at least three:

1) IDE-first (Cursor)
2) terminal-first (Claude Code, Codex CLI)
3) orchestration-first (Codex app)

CNBC explicitly frames this launch as OpenAI trying to win market share from rivals like Anthropic and Cursor.

Engadget frames the Codex app as a step beyond “response to Claude Code” into a more sophisticated, multi-agent direction.

Sources:

My take on the positioning

Cursor feels like “my IDE got superpowers.”
Codex app feels like “my repo got a control room.”

If you’re the kind of dev who:

  • runs multiple projects at once
  • delegates chunks of work to agents
  • reviews diffs rather than watching tokens stream
  • wants long-running tasks to keep going while you context switch

…this “control room” approach makes a ton of sense.

“It looks like Conductor” (and why that’s not an insult)

A bunch of devs have been experimenting with “CLI wrappers” that make multi-thread / multi-project agent work manageable—Conductor being a common reference point.

That’s not copying; it’s convergent evolution. Once you accept “agents are slow but thorough,” the UI you want is basically:

  • project sidebar
  • thread list
  • review pane
  • background work queue

Theo Browne explicitly calls out apps like Conductor as predecessors to this general UI pattern, while arguing Codex’s implementation is the first one that really clicked for him at scale.

What KOLs are saying (hype + real critiques)

The funniest thing about this launch is that the strongest “marketing” isn’t marketing. It’s builders describing a workflow addiction.

Theo Browne (video transcript)

In his walkthrough, Theo claims he stopped using Cursor and barely used Claude Code for ~2 weeks because Codex app feels like a fundamentally different way to manage agent work across projects. His framing:

  • Codex app is an orchestration UI, not “AI inside an IDE”
  • It feels like a UI for the Codex CLI, sharing history/config
  • The killer feature is hopping between parallel tasks without losing context
  • Automations are “cron jobs with prompts”
  • He’s excited enough that he jokes he bought a second laptop just to keep using it

But he’s also not shy about the rough edges:

  • worktrees UX can feel awkward
  • environment variable / dev environment management is unclear
  • constraints around repos/cloud setup can be annoying

Tip: include the video link + timestamps in your published post for clean attribution.

From your screenshot set (high-level themes)

Based on the screenshots you shared, the public vibe clusters into:

Praise:

  • “clean UI”
  • “worktrees built in”
  • “Codex is cool and skillful”
  • real-world use cases beyond app dev (e.g., scripting/automation style tasks)

Criticism:

  • reports of “gets stuck” / spinning / system load issues in certain setups
  • friction with interactive shells / long-running commands (as described by one user)

Include both. Credibility is a feature.

The under-discussed part: the workflow shift

The actual innovation isn’t “it writes code.” It’s:

From: “pair programming with one agent”
To: “supervising a team of agents”

OpenAI’s own language leans into that: supervising coordinated teams across the lifecycle: design → build → ship → maintain.

This matters because it changes what you optimize for:

  • fewer prompts, more delegation
  • fewer inline completions, more batch changes + review
  • fewer “stay in one tab,” more “queue work and hop projects”
  • skills + automations become first-class

If you’ve ever had 4 terminal tabs running Codex and forgotten which one was “the one that’s about to delete your repo,” the appeal is obvious.

Practical advice if you try it this week

1) Treat it like a CI-driven teammate

Let it do the work, but keep the rules:

  • run tests
  • lint/format
  • review diffs
  • don’t merge without understanding the change

2) Start with skills that match your stack

If you’re in the modern TS/Next.js world, the first skills I’d want are:

  • repo bootstrap (install, env sanity checks, test commands)
  • “fix CI failures” skill
  • Linear ticket update skill (if your team lives there)
  • deployment skill (Vercel/Cloudflare) for preview URLs

3) Lock down permissions early

If you’re going to let an agent run commands, sandbox it:

  • restrict folders
  • restrict network
  • require approvals for risky operations

ZDNET’s reporting suggests those controls exist—use them.

So… is it a “Claude killer” or “Cursor killer”?

It’s competing with both, but it’s not the same product.

Cursor is still incredible when you want:

  • tight IDE editing loops
  • UI iteration
  • fast “touch this file right here” work

Agent orchestration shines when you want:

  • big refactors
  • multi-project parallelism
  • long-running tasks
  • “come back with a PR” workflows

The Codex app is OpenAI betting that more of your day will look like the second list.

Sources / further reading

Your turn

If you try the Codex app this week, I’m curious:

  • Does the “command center” UI reduce your context switching?
  • Do skills/automations actually stick, or do they become shelfware?
  • Is worktree isolation a superpower, or just more git complexity with a nicer coat of paint?

Top comments (0)