pub.towardsai.net 6 min read Original Source

Why I Moved My Agentic Coding Harness from Claude Code to Codex

Caspar Bannink

October 27, 2026 · 19 readers

I switched because the daily loop mattered more than the headline model war. Rate limits, latency, tool reliability, and how well the agent keeps going over a long task ended up mattering more than any single score. That is the part that decides whether a harness becomes something I use all day or something I admire in screenshots.

A few weeks ago I wrote about building an agentic coding harness across three CLI hosts. Since then, the center of gravity moved. The harness now treats Codex as the main operating surface, with Codex-native skills, TOML agent routing, and a model-neutral source repo in agentic-coding-kit.

This is not a lab benchmark post. It is a first-person operating decision.

The actual reason for the switch

Claude Code got me much closer to a real coding-agent workflow than most earlier tools did. It made long-running implementation loops, review passes, and repo-aware work feel practical enough to build around.

But practical enough is not the same as best daily driver.

What pushed me toward Codex was that the whole loop started to feel easier to live inside. OpenAI now includes Codex across ChatGPT plans, documents usage by plan, and exposes a rate card that maps usage to token types instead of hiding everything behind vague message estimates. That matters because agentic work is not one prompt and one answer. It is a sequence of reads, edits, retries, tool calls, and validations. When usage visibility is clearer, the harness becomes easier to reason about.

One concrete example from my own workflow: when I am doing a repo-level change that needs exploration, implementation, and then verification, Codex feels better at staying inside that sequence without me constantly re-steering it. In Claude Code I often felt like I was re-establishing context between phases. In Codex, the same kind of task more often feels like one continuous loop: inspect the repo, delegate the exploration pass, make the edit in a constrained surface, run verification, and return a concise result.

OpenAI also positions GPT-5.5 as its strongest Codex model for agentic coding and says it uses significantly fewer tokens to complete the same Codex tasks. That is vendor-reported, not my independent benchmark. Still, when the vendor claim lines up with what feels better in daily use, I pay attention.

The benchmark story is more honest than the usual model tribalism

The most useful part of the GPT-5.5 launch was that it did not show a clean sweep. That makes the comparison more believable.

Here is the compact coding-agent view from OpenAI’s published table:

Benchmark               GPT-5.5  Claude Opus 4.7  What I take from it
----------------------  -------  ---------------  -------------------------------------------------------------
SWE-Bench Pro (Public)  58.6%    64.3%            Opus 4.7 still leads this public coding benchmark
Terminal-Bench 2.0      82.7%    69.4%            GPT-5.5 looks much stronger on terminal-first agent workflows
OSWorld-Verified        78.7%    78.0%            Roughly tied, slight GPT-5.5 edge
GDPval                  84.9%    80.3%            GPT-5.5 leads on broader knowledge-work agent tasks
BrowseComp              84.4%    79.3%            GPT-5.5 leads on browse-and-complete workflows
CyberGym                81.8%    73.1%            GPT-5.5 leads on this security-oriented agent eval

Benchmark               GPT-5.5  Claude Opus 4.7  What I take from it
----------------------  -------  ---------------  -------------------------------------------------------------
SWE-Bench Pro (Public)  58.6%    64.3%            Opus 4.7 still leads this public coding benchmark
Terminal-Bench 2.0      82.7%    69.4%            GPT-5.5 looks much stronger on terminal-first agent workflows
OSWorld-Verified        78.7%    78.0%            Roughly tied, slight GPT-5.5 edge
GDPval                  84.9%    80.3%            GPT-5.5 leads on broader knowledge-work agent tasks
BrowseComp              84.4%    79.3%            GPT-5.5 leads on browse-and-complete workflows
CyberGym                81.8%    73.1%            GPT-5.5 leads on this security-oriented agent eval

That is the honest version.

If your entire workflow is best approximated by SWE-Bench Pro public, the chart does not support a universal “Codex beats Claude” claim. It supports a narrower claim: GPT-5.5 looks stronger on several agentic and computer-use evaluations, while Claude Opus 4.7 still leads at least one prominent public coding benchmark.

That distinction matters because I was not choosing a model for a leaderboard. I was choosing a harness for long-horizon coding work.

Why the harness changed, not just the model

The harness itself also became easier to make explicit in Codex.

My current repo setup supports Codex as a first-class host, with reusable skills, local TOML agent routing, and a source layout that stays model-neutral even when the local machine routes different agents to different models. That separation is important. I do not want the repo to be tightly coupled to one vendor’s runtime assumptions.

The host difference matters here. Claude Code often felt to me like a strong model wrapped in a workflow surface that still needed more manual steering for multi-phase work. Codex feels more natural as an operating surface for routing: exploration can be cheap, implementation can be stricter, review can be adversarial, and verification can be explicit without the whole setup feeling bolted together. That is the product-level reason for the switch, separate from any one benchmark table.

In practice, that gave me three things:

1. A cleaner default loop

The default working loop now feels closer to how I actually code: inspect repo, delegate exploration, implement in a constrained surface, verify, then hand back a concise result.

That sounds obvious, but many agent setups still feel like they were designed for demos. They can do something impressive once, but the cost of steering them through normal work stays too high.

2. Better visibility into usage

OpenAI’s current Codex docs say usage depends on plan and counts toward an agentic usage limit shared with other agentic features. The rate card then breaks cost into input, cached input, and output credits per million tokens.

That is more operationally useful than a fuzzy “messages remaining” mental model when you are running multi-step coding agents.

Source for the table below: OpenAI Help, Codex rate card.

Model          Input credits / 1M  Cached input credits / 1M  Output credits / 1M
-------------  ------------------  -------------------------  -------------------
GPT-5.5        125                 12.50                      750
GPT-5.4        62.50               6.250                      375
GPT-5.3-Codex  43.75               4.375                      350

Model          Input credits / 1M  Cached input credits / 1M  Output credits / 1M
-------------  ------------------  -------------------------  -------------------
GPT-5.5        125                 12.50                      750
GPT-5.4        62.50               6.250                      375
GPT-5.3-Codex  43.75               4.375                      350

Anthropic does publish API pricing, but I have not found an equivalent public Claude Code rate card in the same token-credit format as Codex. That is why I am not forcing a fake one-to-one host cost comparison here.

I am also not claiming audited savings. The narrower claim is that the Codex plan and pricing surface is easier for me to reason about day to day because OpenAI exposes the model credit mapping directly.

3. Better fit for agent routing

A harness is not just one model call. It is a routing system. Some steps are cheap exploration. Some are high-risk implementation. Some are adversarial review. Some are verification. I care less about the mythical single best model and more about whether the host makes this routing natural.

That is also why I think the model conversation is shifting from “Who won?” to “How do I route?”

What this does not prove

There are three claims I am deliberately not making.

First, I am not claiming Codex is universally smarter than Claude Code. The evidence packet does not support that.

Second, I am not claiming I ran a controlled Opus 4.8 comparison. Anthropic announced Claude Opus 4.8 on May 28, 2026, and described Claude Code changes including dynamic workflows in research preview, higher-effort controls, and faster mode pricing changes. I have not personally tried Opus 4.8 enough to say whether it would reverse my decision.

Third, I am not claiming my harness architecture improves benchmark scores by itself. A harness can improve workflow quality, reduce steering overhead, and make model strengths easier to use. That is different from saying it makes the underlying model smarter.

Why this mattered more for me as a solo founder

I am not running a research lab. I am a solo founder building products and internal tooling, including HomeScout, where the real bottleneck is usually execution speed and decision quality under limited time.

That changes the threshold.

A coding harness only earns its place if it helps me finish real work with less friction. If one environment gives me slightly better benchmark bragging rights but another one gives me a more usable daily operating loop, I will choose the second one almost every time.

That is also why I found OpenAI’s GPT-5.5 positioning useful, even with the obvious vendor caveat. Their launch claims emphasized not only stronger agentic coding performance, but also similar per-token latency to GPT-5.4 and fewer tokens for the same Codex tasks. That is vendor-reported, but it is also the kind of claim that maps directly to what I care about in daily use: how often the loop keeps moving without turning into overhead.

Raw intelligence matters. But harness quality is what turns raw intelligence into shipped work.

The bigger lesson: the daily harness is now the product

I think we are leaving the phase where coding agents are judged mostly by isolated answers.

The real battleground now is the working loop:

How long can the agent stay coherent?
How well does it use tools?
How often does it stop early?
How clearly can I reason about usage and limits?
How naturally can I route different tasks to different models or effort levels?
How much correction does the system need before it becomes more work than help?

That is why I moved.

Claude Code still matters, and Anthropic is still shipping serious features. OpenAI pulled ahead for my use case on the combination that actually decides daily adoption: stronger agent workflow signals, a more usable Codex surface, and a harness architecture that now fits the way I want to operate.

If Opus 4.8 changes that after real use, I will say so. Right now, the honest answer is simpler.

Codex became the place where the harness felt most usable.