Claude Code and Codex CLI: The New Coding Agent Era

Two coding agents entered the ring. Both left standing. Here's what I learned.

I've been using Claude Code (Anthropic) and Codex CLI (OpenAI) for about three months now, both on real Sorren.ai engineering tasks — not toy benchmarks, not contrived examples, the actual work of maintaining and extending the infrastructure. They're both good. They're good at different things. And the differences matter.

The Benchmark Setup

I ran both agents against a set of real tasks from the previous month's work:

1. Refactor the RAG pipeline to support streaming retrieval (architectural)
2. Implement a new Grafana dashboard for adapter swap latency (well-specified)
3. Debug a memory leak in the inference server (investigative)
4. Add Prometheus metrics to the vector DB query layer (well-specified)
5. Redesign the LoRA adapter loading system (architectural)

Tasks 1 and 5 involve understanding the whole system before changing it. Tasks 2 and 4 involve clear specs and isolated scope. Task 3 is a different beast — pure debugging, requiring hypothesis generation and systematic elimination.

Claude Code: The Architect

Claude Code excels at tasks that require understanding context before acting. Give it the RAG pipeline refactor and it will read the existing code, understand how the components interact, identify the coupling points, and propose a redesign that accounts for downstream effects. It holds the whole system in its head — or whatever the LLM equivalent of a head is.

On the architectural tasks (1 and 5), Claude Code produced solutions I actually shipped with minimal revision. It understood why the current design existed before proposing changes to it. That's the key thing — it doesn't just generate code, it reasons about code within a system.

# Claude Code on the RAG refactor
claude refactor rag/pipeline.py --streaming-support \
  --preserve-backward-compat

Its weakness is speed. Claude Code is thorough, and thoroughness takes time. On the well-specified tasks (2 and 4), it produced correct solutions but took longer than felt necessary. It's an agent that wants to understand the whole problem before touching anything, even when the problem is small.

Codex CLI: The Implementer

Codex CLI is faster. Noticeably, measurably faster. Give it a well-specified task and it will produce correct, working code with minimal back-and-forth. On the Grafana dashboard task, Codex had a working panel with correct PromQL queries in about two minutes. Claude Code took closer to eight.

# Codex CLI on the metrics task
codex "Add Prometheus /metrics endpoint to qdrant_query.py.
       Expose query_count, query_latency_seconds (histogram),
       and index_size_gauge."

Where Codex struggled was the architectural tasks. On the RAG pipeline refactor, it produced code that worked in isolation but didn't account for how the subconscious process depended on the current retrieval interface. It solved the immediate problem. It didn't solve the system problem.

The debugging task (3) was interesting. Both agents eventually found the memory leak — a LoRA adapter that wasn't being properly unloaded during swap. Claude Code got there by reasoning about the adapter lifecycle. Codex got there by systematically profiling and narrowing down. Different paths, same destination, roughly similar time.

Head-to-Head Results

| Task | Claude Code | Codex CLI | Winner | |------|-----------|-----------|--------| | RAG refactor (architectural) | Shipped with minor revisions | Needed rework — missed downstream coupling | Claude Code | | Grafana dashboard (specified) | Correct, 8 min | Correct, 2 min | Codex CLI | | Memory leak debug (investigative) | Found it via reasoning | Found it via profiling | Tie | | Prometheus metrics (specified) | Correct, 6 min | Correct, 2 min | Codex CLI | | LoRA loading redesign (architectural) | Strong design, shipped | Missed key constraints | Claude Code |

The pattern is clear. Claude Code wins on architecture and context-heavy reasoning. Codex CLI wins on speed and well-specified implementation. Neither is strictly better — they're different tools for different jobs.

The Three-Agent Workflow

Here's where it gets useful. I don't pick between them. I use both, orchestrated by Hermes.

Task arrives →
  Hermes (orchestration): understands the task, decides routing
    ├── Architectural / system-level → Claude Code
    ├── Well-specified / isolated → Codex CLI
    └── Investigative / debugging → either, often both in parallel

Hermes acts as the orchestrator. It receives the task, understands the context (because it has memory — it knows the codebase, the conventions, the architecture), and delegates to the right agent. For complex tasks, it splits the work: Claude Code designs, Codex implements.

A concrete example from last week: redesigning the adapter loading cache. Hermes broke it into three parts — Claude Code designed the new caching strategy, Codex CLI implemented the LRU eviction logic, and Codex CLI (in a separate subagent) wrote the tests. Total wall-clock time: 23 minutes. I reviewed the PR, approved it, shipped it.

Doing that by hand would have been an afternoon.

What This Means

I'm writing less code and reviewing more. The agents handle the implementation — I handle the judgment calls, the architecture decisions, the "should we even do this" questions that require knowing the business, not just the codebase.

My role is shifting from "person who writes code" to "person who decides what code gets written and verifies it's right." The agents are genuinely good now. Not perfect — I catch errors, I reject proposals, I redirect approaches. But the volume of code I'm shipping has roughly tripled, and the quality hasn't dropped.

Two coding agents entered the workflow. They're both staying. And Hermes is the one deciding which one gets which task, which is a sentence I didn't expect to be writing two years ago.