AI Coding Harnesses in 2026: Claude Code, Codex, Antigravity, Goose, OpenCode, and Pi

The models are getting better, but the model is no longer the whole product. The harness around it decides what context gets loaded, which tools are available, how permissions work, whether a task survives compaction, and how quickly I burn through a subscription limit.

That is the part I wanted to understand. Claude Code has been my default, but lately I have felt more context overhead and more friction than I remember. At the same time, Codex has matured, open-source tools have become genuinely usable, and Google has turned Antigravity into a whole family of agent products.

So I did some digging and compared the tools I would actually consider using. This is not a benchmark pretending that one score can pick a daily driver. It is my practical read on what each harness feels optimized for, what it asks me to give up, and where the subscription limits start to matter.

Claude Code (Anthropic)

Claude Code is still the heavyweight option for me. It is opinionated, deeply integrated with Claude models, and unusually good at turning a vague coding request into a sequence of useful actions.

Benefits

The best thing about Claude Code is how little ceremony it needs. I can open a large, unfamiliar repository, give it a goal, and usually trust it to inspect the right files before editing. Its defaults feel tuned for real software work rather than a tool-calling demo.

It also has a serious extension story. CLAUDE.md, skills, subagents, agent teams, hooks, MCP servers, permission modes, and worktree isolation cover most of the workflow tweaks I have wanted. Anthropic’s feature overview explains how those pieces fit together without forcing everything into the main context.

For long refactors, debugging sessions, and tasks that need several rounds of testing, it remains the harness I trust most to keep moving without constant supervision.

Drawbacks

That polished behavior comes with a lot happening behind the curtain. I can inspect my project instructions and extensions, but I do not control the core harness or the decisions Anthropic has made about prompting, compaction, and tool behavior. When a session starts feeling clumsy, it is hard to tell whether the problem is my prompt, the model, or the machinery around it.

The context overhead is also real. I am deliberately not attaching a fake universal token number to it because the total changes with tools, project instructions, MCP servers, skills, and subagents. My practical complaint is simpler: Claude Code can spend a surprising amount of context before the interesting part of the task begins.

Usage is shared across Claude and Claude Code, and heavy repository work consumes the allowance much faster than chat. Anthropic now lets subscribers continue with usage credits, but the current plan documentation still makes Max feel like the realistic tier for a heavy daily user.

Codex (OpenAI)

Codex is no longer just a terminal agent or just a hosted container. OpenAI now offers it across the CLI, IDE extension, desktop app, and cloud, with the GPT-5.6 family as the current coding lineup.

Benefits

In my use, Codex is excellent when the outcome is concrete: build this screen, fix this bug, migrate this API, or make these tests pass. It writes clean code, checks its work, and tends to be economical with context compared with Claude Code on similarly bounded tasks.

The local and cloud split is useful once it is described accurately. The CLI works directly in my local repository, while cloud tasks run in isolated containers that check out the repository, execute setup steps, and return a diff. OpenAI’s cloud environment documentation lays out that flow clearly.

Codex also supports long-running goals, parallel work, worktrees, reusable skills, plugins, MCP, and repository instructions through AGENTS.md. It has become a much more complete harness than the early CLI suggested.

Drawbacks

Codex still feels more execution-first than conversational. I like that when the task is crisp, but for open-ended architecture work I sometimes miss Claude Code’s tendency to narrate the problem and build a stronger shared picture before editing.

Cloud tasks introduce a boundary around the environment. Dependencies, setup scripts, network access, and secrets need to be configured for the container rather than assumed from my laptop. That isolation is a feature, but it is not free convenience.

The pricing story also changed in 2026. Included usage remains part of ChatGPT plans, but overages are now token-based credits, and Codex shares an agentic usage pool with other supported ChatGPT features. The current Codex rate card is clearer than the old per-message estimates, but it also makes heavy use easier to meter and easier to spend money on.

Antigravity (Google)

Antigravity is Google’s broadest answer to agentic development. It now includes a standalone Antigravity 2.0 desktop app, a terminal CLI, an IDE, and a Python SDK, all built around the same agent harness.

Benefits

The product is more interesting than I first gave it credit for. Antigravity 2.0 can coordinate local agents and subagents across projects and worktrees, run scheduled tasks, connect to MCP servers, and control Chrome for browser testing. Its artifacts include plans, diffs, screenshots, and browser recordings, which makes autonomous work easier to audit.

Google also gives the surfaces distinct jobs. The desktop app is a command center, the CLI is the keyboard-first option, the IDE is the integrated coding environment, and the SDK is for building custom agents. The Antigravity overview makes that separation much clearer than the original launch messaging did.

There is real model choice too, including Gemini models and, on the Ultra tier, third-party models such as Claude. For someone already deep in Google Cloud, Firebase, Android, and Chrome tooling, the integration story is compelling.

Drawbacks

The limits are the part I cannot ignore. Google’s current plans page does not publish a simple prompt or token allowance that I can compare directly with Claude Code or Codex. It says quotas depend on capacity and on how much work the agent performs, with a five-hour refresh for paid tiers and a weekly ceiling. Once the baseline is gone, I either wait or pay for overage credits. There is no bring-your-own-key or custom endpoint to escape the limit.

Google’s own May 2026 plan announcement is more revealing than the word “generous” on the plans page. It positions the $20 Pro quota as suitable for experimentation, the $100 Ultra tier for lighter but regular development, and the $200 Ultra tier as the strongest daily-driver option. It also says the $100 and $200 tiers provide 5x and 20x the $20 quota, while third-party models remain on a separate fixed limit because capacity is tight.

That sounds worse to me than the practical value I get from Codex or Claude Code at comparable subscription prices. I cannot prove that with a clean tokens-per-dollar table because the vendors do not expose compatible numbers, but I do not need fake precision to see the warning sign. If the $20 plan is framed as experimentation and the $100 plan as lighter regular use, I would not buy Antigravity expecting an unconstrained daily driver.

The breadth also creates more surface area to configure. Projects, policies, models, MCP servers, browser access, the desktop app, CLI, IDE, and SDK are powerful together, but they are a lot to learn. Antigravity may become the most cohesive ecosystem here. Today, the quota model makes it the hardest one for me to recommend as a primary paid harness.

Goose (Block / Agentic AI Foundation)

Goose is an open-source agent for code and repeatable workflows. It comes as a desktop app, CLI, and API, and it now lives under the Linux Foundation’s Agentic AI Foundation.

Benefits

Goose gives me control over both the harness and the provider. I can use Anthropic, OpenAI, Google, Ollama, or another supported backend, and I can choose whether I want API keys or an existing subscription through ACP. That is a much cleaner answer to lock-in than buying a second closed harness.

Recipes are the part that makes Goose more than another chat loop. They are portable YAML workflows that can include instructions, parameters, extensions, and subrecipes. A team can keep a weekly status workflow or release checklist in version control instead of copying prompts around Slack.

The project also has deep MCP support, subagents, permission controls, and a sandbox. The official Goose overview is refreshingly specific about the supported surfaces and providers.

Drawbacks

Goose asks me to assemble more of the experience myself. Choosing a provider is easy; choosing a model, configuring extensions, controlling costs, and making a recipe robust across messy repositories still takes work.

There is also an important privacy footnote. The agent runs on my machine, but prompts still leave my machine when I select a hosted model. Truly local data flow requires a local model, not merely a local harness.

My other hesitation is focus. Goose is becoming a broad automation platform, which is useful, but Claude Code still feels more tightly tuned for the specific loop of inspect, edit, test, and recover inside a difficult codebase.

OpenCode (Anomaly)

OpenCode is the model-switcher’s terminal agent. It is open source, runs locally, and supports a huge catalog of hosted and local models through the AI SDK and Models.dev.

Benefits

The killer feature is still model choice. OpenCode documents support for more than 75 providers, and switching models does not require switching my entire terminal workflow. That is excellent when I want Claude for one task, a Codex model for another, and a cheap local model for routine edits.

It is more capable than the phrase “thin wrapper” suggests. OpenCode has primary agents, subagents, child sessions, granular permissions, custom tools, and MCP support. Its agent configuration is straightforward enough that I can understand what is happening without maintaining my own harness fork.

For client work and model experiments, this is the open-source tool I can get productive with fastest.

Drawbacks

Provider breadth is also operational clutter. I own the API keys, billing accounts, model quirks, and configuration. A prompt that works beautifully with one provider can become indecisive or reckless with another, so model switching is not always as seamless as the menu makes it look.

Like Goose, local execution does not automatically mean local inference. If I connect OpenCode to Anthropic or OpenAI, project context still goes to that provider. The local story is strongest when I pair it with a local model.

OpenCode has sessions and subagents, so saying it cannot handle longer work would be unfair. My issue is more subjective: it feels like a flexible workbench, while Claude Code feels like someone already tuned the bench for coding. I get more control, but I also inherit more decisions.

Pi Coding Agent (Earendil Works)

Originally built by Mario Zechner, Pi is the minimalist counterpoint to all of this. It starts with a small coding loop, a compact prompt, and a few core tools, then lets me replace or extend almost every part. The project moved to Earendil Works in May 2026.

Benefits

Pi puts context ownership front and center. It loads AGENTS.md or CLAUDE.md, exposes token and cost information in the UI, and lets me replace or append to the system prompt. Sessions can be resumed, forked, cloned, compacted, or navigated as a tree.

Its TypeScript extension API can add tools, hooks, commands, UI elements, model providers, and custom behavior. The Pi coding agent README reads more like a box of sharp primitives than a product funnel, which is exactly the appeal.

If I want to understand every layer between my prompt and the model, Pi is the cleanest option here.

Drawbacks

Pi gives me primitives, not a finished opinion about how I should work. That means I need to create the plan files, prompts, extensions, permission rules, and conventions that a batteries-included harness provides on day one.

The result can be brilliant, but only after I invest in harness engineering. There is a point where maintaining my perfect agent becomes a hobby that competes with the software I meant to build.

That makes Pi a great fit for people who enjoy owning the stack and a weaker fit for anyone who just wants the agent to open a monorepo and get on with it.

Slimmer Harness Examples & Patterns

Beyond Pi, there is a growing family of small agent loops in Python, Go, Rust, and TypeScript. Most reduce the harness to the same few pieces:

• A small system prompt.
• File, shell, search, and edit tools.
• A permission boundary.
• Session state and optional compaction.
• Hooks for whatever the author actually needs.

The appeal is not that a 500-line agent automatically beats Claude Code. It is that I can read it, debug it, and change its behavior without waiting for a vendor. The cost is that I also own every rough edge.

I would start from an existing minimal harness before writing another one. The core loop is simple, but model quirks, terminal rendering, cancellation, tool errors, and safe permissions are where a weekend project quietly becomes infrastructure.

Notable but Not Included

Cursor, Cline, GitHub Copilot, and the various VS Code agent modes belong in a neighboring comparison. They have serious harness capabilities, but an IDE-first product changes the workflow enough that comparing it directly with a terminal agent becomes noisy.

OpenClaw and Hermes sit on the other side of the boundary. They are general agents that can code, remember, schedule, and automate across a wider personal environment. That is interesting, but it is a different job from being my coding harness inside one repository.

How to Choose Between Them

• If you want the strongest out-of-the-box autonomy on a difficult codebase, pick Claude Code.

• If you want crisp implementation, local and cloud execution, and a more efficient-feeling context budget, pick Codex.

• If you want Google’s desktop, CLI, IDE, SDK, browser, and cloud integrations in one family, try Antigravity, but inspect your actual quota before making it a daily driver.

• If you want model freedom without building your own harness, pick OpenCode.

• If you want repeatable team workflows and broad automation through open standards, pick Goose.

• If you want to own the prompt, tools, UI, and event loop, pick Pi.

The Honest Verdict

Claude Code is still my default for large, autonomous repository work. It is expensive and sometimes opaque, but it remains the harness I trust most when the job is messy and I do not want to babysit every step. Codex is my first alternative for focused implementation and parallel work.

Antigravity has become much more capable than a simple Gemini IDE, but the current limits undercut the pitch. Until Google publishes clearer allowances or makes the lower tiers feel like real daily-driver plans, I would treat it as an impressive secondary tool, not the replacement for Claude Code or Codex.

OpenCode is the better escape hatch when I want provider freedom, while Pi is the option I admire when I want full ownership. Goose makes the most sense when the repeatable workflow matters more than the coding chat itself.