Codex, Grok Build and OpenClaude differ less in features than in where they put the rules

Same features, different foundations

As dev.to reported, a developer has laid out how three terminal-based coding agents are built: Grok Build, Codex and OpenClaude. A coding agent here means a program that reads your code, edits files, runs commands and calls outside tools while an AI model decides what to do next. All three can do all of that, plus sessions you can resume, hooks and plugins, project instruction files and sub-agents.

The author's point is that the feature checklist is close to a tie. What separates the tools is which layer of the software owns each job. The piece also gives a timeline: Claude came before the project nicknamed OpenClaw, while Grok Build and Codex came after, so those two sit closer to OpenClaw's way of handling queries and sessions.

One caution on naming: the third tool in the comparison is OpenClaude, a community project whose repository the author says carries traces of Claude Code. It is not Anthropic's own product.

Three ways to wire the core

Codex works like a mailbox. The front end, whether a terminal screen, a script or an SDK, sends an operation to the session and gets a stream of events back. Because every client talks to the same bus, the protocol stays stable, runs can be audited, and editors or cloud services can reuse the same session model.

Grok Build splits the work into independent actors, which are components that each run their own loop and pass messages. One actor handles the model's raw output, retries, cancellation and detection of the agent going in circles. The session itself speaks ACP, a protocol that lets editors embed an agent, so the terminal, editors and headless mode can share one agent.

OpenClaude runs as one process built around a single loop that hands messages along as it goes. Tools, compaction (summarizing history so context does not grow without limit) and permissions all hang off that loop. The author says this makes features quick to change and the call stack easy to follow, but gives weaker boundaries between parts than the other two.

Where safety and model support live

Sandboxing, which limits what a program can touch, sits in different places. Codex decides at each tool call: ask for approval, pick a sandbox, run, and if it is blocked, retry with higher privileges without asking again. Separate components named execpolicy and Guardian check whether what the user approved really covers the specific action.

Grok Build wraps the whole process in operating-system sandboxing at startup, then puts tighter network limits on child processes. It also has permission rules, sandbox profiles and hooks that can allow, ask about or deny a tool call. OpenClaude analyzes commands and applies permission rules first, then relies on an external sandbox package. The author notes that this is flexible, but the strength of isolation depends on how completely the rules are written.

Model support follows a similar split. Codex is designed around OpenAI's Responses API, with local models added as extra clients. Grok Build confines vendor differences to its sampling layer, which supports three API styles. OpenClaude keeps Anthropic's message format internally and translates for other vendors, which gives it the widest coverage but also the most patches. Even its small internal calls, like compaction and evaluation, go through that translation, so reliability on non-Anthropic models depends on how good it is.

Who decides the job is done

This may be the most practical difference. In Grok Build, the harness, meaning the program around the model, enforces a flow with several skeptical checkers before a task counts as finished. Agent definitions can also require a particular tool call before a turn may end.

Codex mainly prompts the model to audit its own work, and keeps action safety as a separate job for Guardian. OpenClaude uses a lightweight evaluator, and its heavier verification agent runs only when the model chooses to call it. So in one design the harness forces checking, in another the model checks itself, and in the third verification is optional.

Editing differs too. Grok Build uses hashline anchors, which tie each edit to a specific line in a way that can be verified, so the agent is less likely to change the wrong one.

Reading it with care

The comparison also lists size and licensing. Grok Build is about 1.98M lines including generated and third-party code, and Codex's Rust part is about 2M lines. OpenClaude is about 670K lines excluding tests. Grok Build and Codex are Apache-2.0 and accept no external code contributions, while OpenClaude is described as MIT-leaning and community-friendly.

These are one developer's observations from reading repositories, not benchmark results. They say how the tools are built, not which one performs best on your work. If you run an open model inside an agent harness, session handling and the checks around the model shape cost, reliability and debugging as much as the model does.