Source: Grok conversation share on X · Generated with kg-generator + rdf-infographic-skill

Coding Agent Harness Comparison: Pi vs OpenCode vs Claude Code vs Codex

Tabulated comparison of four coding agent harnesses — philosophy, tools, models, safety, and fit (Grok share, 2025–2026 sources)

KG curated by kg-generator, rdf-infographic-skill, and Grok 4.5 on behalf of Kingsley Idehen

Synopsis¶

Tabulated comparison of four coding agent harnesses — Pi, OpenCode, Claude Code, and Codex (CLI) — covering creators, license, philosophy, tools, model support, extensibility, safety, strengths, weaknesses, best-fit use cases, and pricing (sources 2025–2026).

View this analysis as a KG entity

Head-to-Head Comparison¶

Tabulated comparison from the Grok share (sources 2025–2026). On larger screens this is a matrix; on phones it becomes one card per harness. Entity names resolve via URIBurner.

Aspect	Pi	OpenCode	Claude Code	Codex (CLI)
Creator / Backer	Mario Zechner / Earendil (independent)	Anomaly (ex-SST), community-driven	Anthropic	OpenAI
License / Openness	MIT (fully open source)	MIT (fully open source)	Proprietary (closed)	Apache 2.0 (harness open; models closed)
Core Philosophy	Minimalist & transparent: tiny prompt, 4 core tools, you own/extend everything	Model-agnostic, community-driven, practical open alternative with good orchestration	Heavyweight, batteries-included, deep integration & autonomy	Reliable engineering focus with strong sandboxing and model strength
System Prompt / Overhead	Very small (~200–1,000 tokens)	Moderate (~few–10k tokens range)	Large (~10k+ tokens, extensive rules/tools)	Moderate / relatively efficient
Default Tools	4 core (read, write, edit, bash) + optional read-only	Claude-style set + LSP, MCP, search orchestration	Many (10–25+: Read/Write/Edit/Bash/Glob/Grep/Web/Notebook/Task/sub-agents, etc.)	~10 tools; strong emphasis on safe execution
Model Support	Highly flexible (15+ providers, 300+ models, BYOK, local/Ollama)	Highly flexible (75+ providers via Models.dev, BYOK, local)	Primarily Claude models (limited others with setup)	Primarily OpenAI/Codex models (Ollama official; others community)
Extensibility	Excellent (TypeScript extensions, skills, packages, RPC/SDK)	Strong (plugins, MCP, community, multi-surface)	Strong built-in (hooks, skills, MCP, sub-agents, teams, CLAUDE.md rules)	Good but younger extensibility; solid architecture
Safety / Permissions	YOLO by default (user in control; container isolation preferred)	Safer defaults, configurable	Deny-first, rich permission modes, sandboxing	Strong OS-enforced sandboxing (Seatbelt/bubblewrap), network denied by default
Key Strengths	Token efficiency, transparency, customizability, low lock-in, predictability	Model freedom, polished open-source experience, multi-session/LSP, cost control	Deep repo integration, multi-agent, long-horizon tasks, polished autonomy	Model quality, reliability, sandboxing, token efficiency on many tasks
Key Weaknesses	Fewer built-ins (sub-agents/plan mode via extensions); less hand-holding	Can feel less “magical” than lab tools; community polish varies	High token use/cost, model lock-in, more “magic”/opacity	Model lock-in, less mature extensibility vs pure open tools
Best For	Custom/scripted loops, full visibility, builders who want control, multi-model/cost-sensitive work	Open-source, model-agnostic setups (e.g., OpenRouter), flexible daily use	Complex multi-step repo work, conventions/tests, autonomous deep engineering	GPT/Codex users wanting solid sandboxing & reliability; second opinions or structured tasks
Pricing Model	Free (BYOK / pay provider)	Free (BYOK / pay provider; some hosted options)	Subscription ($20–200/mo tiers) or API	ChatGPT plan credits / API (tied to OpenAI)

Pi MIT · minimal

Creator / Backer

Mario Zechner / Earendil (independent)

License / Openness

MIT (fully open source)

Core Philosophy

Minimalist & transparent: tiny prompt, 4 core tools, you own/extend everything

System Prompt / Overhead

Very small (~200–1,000 tokens)

4 core (read, write, edit, bash) + optional read-only

Highly flexible (15+ providers, 300+ models, BYOK, local/Ollama)

Excellent (TypeScript extensions, skills, packages, RPC/SDK)

Safety / Permissions

YOLO by default (user in control; container isolation preferred)

Token efficiency, transparency, customizability, low lock-in, predictability

Fewer built-ins (sub-agents/plan mode via extensions); less hand-holding

Custom/scripted loops, full visibility, builders who want control, multi-model/cost-sensitive work

Free (BYOK / pay provider)

OpenCode MIT · open

Creator / Backer

Anomaly (ex-SST), community-driven

License / Openness

MIT (fully open source)

Core Philosophy

Model-agnostic, community-driven, practical open alternative with good orchestration

System Prompt / Overhead

Moderate (~few–10k tokens range)

Claude-style set + LSP, MCP, search orchestration

Highly flexible (75+ providers via Models.dev, BYOK, local)

Strong (plugins, MCP, community, multi-surface)

Safety / Permissions

Safer defaults, configurable

Model freedom, polished open-source experience, multi-session/LSP, cost control

Can feel less “magical” than lab tools; community polish varies

Open-source, model-agnostic setups (e.g., OpenRouter), flexible daily use

Free (BYOK / pay provider; some hosted options)

Claude Code Proprietary

Creator / Backer

Anthropic

License / Openness

Proprietary (closed)

Core Philosophy

Heavyweight, batteries-included, deep integration & autonomy

System Prompt / Overhead

Large (~10k+ tokens, extensive rules/tools)

Many (10–25+: Read/Write/Edit/Bash/Glob/Grep/Web/Notebook/Task/sub-agents, etc.)

Primarily Claude models (limited others with setup)

Strong built-in (hooks, skills, MCP, sub-agents, teams, CLAUDE.md rules)

Safety / Permissions

Deny-first, rich permission modes, sandboxing

Deep repo integration, multi-agent, long-horizon tasks, polished autonomy

High token use/cost, model lock-in, more “magic”/opacity

Complex multi-step repo work, conventions/tests, autonomous deep engineering

Subscription ($20–200/mo tiers) or API

Codex (CLI) Apache 2.0 harness

Creator / Backer

OpenAI

License / Openness

Apache 2.0 (harness open; models closed)

Core Philosophy

Reliable engineering focus with strong sandboxing and model strength

System Prompt / Overhead

Moderate / relatively efficient

~10 tools; strong emphasis on safe execution

Primarily OpenAI/Codex models (Ollama official; others community)

Good but younger extensibility; solid architecture

Safety / Permissions

Strong OS-enforced sandboxing (Seatbelt/bubblewrap), network denied by default

Model quality, reliability, sandboxing, token efficiency on many tasks

Model lock-in, less mature extensibility vs pure open tools

GPT/Codex users wanting solid sandboxing & reliability; second opinions or structured tasks

ChatGPT plan credits / API (tied to OpenAI)

Minimal vs heavyweight Pi sits at the extreme minimal end (less between you and the model). Claude Code is the feature-rich heavyweight. OpenCode and Codex sit in between — openness/flexibility vs engineering reliability + sandboxing.

Token efficiency Pi and Codex often use far fewer input tokens than Claude Code on comparable tasks due to lighter prompts/tools.

Performance context Results vary by task and model. Claude Code and Codex frequently top complex autonomous work; Pi and OpenCode excel when flexibility, cost, or transparency matter. The harness itself meaningfully affects outcomes even with the same model.

Choice heuristic Deep multi-step repo work → Claude Code; OpenAI ecosystem + reliability → Codex; maximum control/transparency/custom loops → Pi; open multi-model without lock-in → OpenCode.

Related sources cited in the conversation: vuink.com comparison · agenticschool.dev · zenn.dev token notes

People¶

Grok

xAI conversational assistant that authored the tabulated harness comparison in the shared conversation.

Kingsley Uyi Idehen

Founder & CEO of OpenLink Software; Semantic Web pioneer and principal operator for this knowledge-graph collection. Curates agent skills and RDF-backed infographics connecting coding-agent harnesses to Linked Data tooling (Virtuoso, URIBurner).

Mario Zechner

Independent creator associated with the Pi coding agent harness (Earendil).

Organizations¶

Earendil

Independent backer associated with the Pi coding agent harness.

Anomaly

Organization (ex-SST roots) associated with the community-driven OpenCode harness.

Anthropic

AI research company that builds Claude models and the proprietary Claude Code coding agent harness compared in this analysis.

OpenAI

AI research company behind Codex (CLI) and the GPT/Codex model family referenced in the harness comparison.

xAI

Company behind Grok, which authored the tabulated coding-agent harness comparison in the source conversation share.

X (social network)

Social network that hosts the Grok conversation share used as the source document for this knowledge graph.

Frequently Asked Questions¶

What is a coding agent harness?▼

A coding agent harness is a wrapper around one or more large language models that supplies tools for file I/O, shell commands, context management, and autonomous iteration on software tasks — turning a chat model into an agentic coding system.

How do Pi, OpenCode, Claude Code, and Codex differ at a high level?▼

They differ mainly in philosophy, model flexibility, feature richness, and openness. Pi is minimalist and transparent; OpenCode is open and model-agnostic; Claude Code is a heavyweight batteries-included Anthropic product; Codex emphasizes engineering reliability and OS sandboxing in the OpenAI ecosystem.

Which harnesses are fully open source?▼

Pi and OpenCode are MIT-licensed and fully open source. Codex's harness is Apache 2.0 open while its models remain closed. Claude Code is proprietary/closed.

Which harness is best for multi-model BYOK setups?▼

Pi and OpenCode lead on model flexibility. Pi cites 15+ providers and 300+ models; OpenCode cites 75+ providers via Models.dev, both with BYOK and local options. Claude Code and Codex primarily target their lab's models.

Which harness has the smallest system-prompt overhead?▼

Pi reports a very small overhead (~200–1,000 tokens). Codex is moderate/efficient. OpenCode is moderate (few–10k). Claude Code is large (~10k+ tokens with extensive rules and tools).

How do safety and permissions compare?▼

Pi defaults to YOLO with user control and prefers container isolation. OpenCode uses safer configurable defaults. Claude Code is deny-first with rich permission modes. Codex uses strong OS-enforced sandboxing (Seatbelt/bubblewrap) with network denied by default.

When should I choose Claude Code?▼

Choose Claude Code for complex multi-step repository work, strong convention/test adherence, multi-agent orchestration, and polished long-horizon autonomous engineering — accepting higher token cost and Claude-centric model lock-in.

When should I choose Pi?▼

Choose Pi for maximum control and transparency, custom/scripted loops, token efficiency, and multi-model or cost-sensitive workflows where you want minimal intermediary magic between you and the model.

When should I choose OpenCode?▼

Choose OpenCode for open-source, model-agnostic daily driving — for example OpenRouter or multi-provider BYOK — with solid MCP/LSP orchestration and community plugins without proprietary lock-in.

When should I choose Codex CLI?▼

Choose Codex CLI if you are invested in the OpenAI/ChatGPT ecosystem and want solid OS sandboxing, reliability, and structured task execution, or a strong second opinion beside another harness.

Does the harness matter if the underlying model is the same?▼

Yes. Sources emphasize that the harness meaningfully affects outcomes even with the same model — via prompt overhead, tool design, permission defaults, multi-agent orchestration, and sandboxing constraints.

What is a practical multi-harness strategy?▼

Many practitioners keep more than one harness installed and switch by task: Claude Code for deep repo autonomy, Codex for OpenAI reliability and sandboxing, Pi for transparent custom loops, OpenCode for open multi-model work. Docs and features change quickly, so re-check current releases.

Glossary of Terms¶

Creator / Backer

Organization or individual that creates or backs the harness.

License / Openness

Software license and openness of harness source code versus model weights.

Core Philosophy

Design intent: minimalist, model-agnostic, heavyweight, or reliability-first.

System Prompt / Overhead

Approximate token cost of system prompt and default tool schemas.

Default Tools

Built-in tool surface for file I/O, shell, search, MCP, and sub-agents.

Model Support

Which LLM providers and models the harness can use.

Extensibility

Skills, plugins, MCP, hooks, SDK, and community extension mechanisms.

Safety / Permissions

Default permission posture and sandboxing model.

Key Strengths

Primary advantages relative to peer harnesses.

Key Weaknesses

Primary trade-offs relative to peer harnesses.

Best For

Use cases where the harness is the strongest fit.

Pricing Model

How users pay: free BYOK, subscription tiers, or API credits.

Coding agent harness

Wrapper around LLMs providing tools, context management, and orchestration for autonomous coding.

BYOK

Bring Your Own Key — the user supplies API keys for LLM providers rather than paying only through a fixed subscription.

MCP

Model Context Protocol — a standard way for agents to attach external tools and data sources.

LSP

Language Server Protocol — used by some harnesses for structured code intelligence (diagnostics, symbols, navigation).

Sandboxing

Isolation of agent-executed commands from the host system (containers, Seatbelt, bubblewrap, network deny-by-default).

System prompt overhead

Tokens consumed by the harness's standing instructions and tool schemas before the user's task tokens.

Sub-agent

A delegated agent instance spawned by a parent harness to handle a scoped subtask.

YOLO mode

Permission posture that allows the agent broad freedom by default, relying on the user or outer isolation for safety.

Token efficiency

How few input tokens a harness needs for comparable tasks — driven by prompt size and tool schemas.

Model lock-in

Dependency on a single lab's models or APIs that raises switching costs across harnesses and providers.

How-To Guide¶

1

Clarify the dominant workload

Decide whether your primary work is deep multi-step repository autonomy, structured single tasks, custom scripted loops, or daily multi-model exploration.

2

Decide openness and lock-in tolerance

If you need fully open harness source and provider freedom, shortlist Pi and OpenCode. If you accept lab lock-in for polish, consider Claude Code or Codex.

3

Match safety posture to environment

Prefer deny-first or OS sandboxing (Claude Code, Codex) on shared/production machines; Pi's YOLO mode is better with strong container isolation and trusted local repos.

4

Budget tokens and dollars

Estimate monthly spend. Heavyweight prompts and multi-agent Claude Code workflows can cost more; Pi and Codex often use fewer input tokens; BYOK open harnesses shift cost to provider APIs.

5

Check model access you already have

If you already pay for Claude, Claude Code is a natural fit. ChatGPT/API users lean Codex. Multi-provider or local-model users lean Pi or OpenCode.

6

Prototype on one real repository task

Run the same non-trivial task (test fix + PR draft) in your top two harnesses and compare autonomy quality, permission friction, and token use — not just marketing claims.

7

Keep a multi-harness toolkit

Install more than one harness and switch by task class. Revisit docs often — features, stars, and benchmarks in this space move quickly.

About This Page¶

This knowledge graph overview was generated by querying the URIBurner SPARQL endpoint for the named graph https://linkeddata.uriburner.com/DAV/demos/daas/coding-agent-harness-comparison-pi-opencode-claude-codex-grok-4-5-1.ttl. The original document was transformed into RDF using kg-generator, rdf-infographic-skill, then uploaded to the Virtuoso-based URIBurner server. The HTML infographic was then rendered using kg-generator, rdf-infographic-skill, powered by Grok 4.5, and running on Virtuoso.

Technology Stack:

Skills: kg-generator, rdf-infographic-skill
Language Model: Grok 4.5
Server Platform: Virtuoso
Knowledge Graph: URIBurner

Knowledge Graph Explorer¶

Interactive graph visualization derived from the companion RDF. Click nodes to resolve, drag to explore. Graph data embedded from companion RDF at generation time.

Coding Agent Harness Comparison: Pi vs OpenCode vs Claude Code vs Codex

Nodes: 0 Links: 0

Click SVG to activate zoom, click outside to release | Drag nodes to pin, double-click to unpin

Classes Properties Instances

SPARQL Workbench¶

Sample queries for this proof of concept, plus a free-form editor. Use the default endpoint or copy queries to your own SPARQL client.

Custom Query Editor

SPARQL Query

🔗 Run live SELECT: text/x-html+tr | DESCRIBE/CONSTRUCT: text/x-html-nice-turtle

Attribution & Provenance¶

SAMPLE query used by the explore button

Canonical entity-type summary scoped to the uploaded Turtle named graph. The full interactive workbench is in the SPARQL Workbench section above.

SELECT ?type (SAMPLE(?s) AS ?sampleEntity) (SAMPLE(?label) AS ?sampleLabel) (COUNT(?s) AS ?entityCount)
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/coding-agent-harness-comparison-pi-opencode-claude-codex-grok-4-5-1.ttl> {
    ?s a ?type .
    OPTIONAL { ?s rdfs:label|<http://schema.org/name> ?label }
  }
}
GROUP BY ?type
ORDER BY DESC(?entityCount)

Source material

Grok conversation share

Pi · OpenCode · Claude Code · Codex harness comparison (tabulated)

Companion files

RDF Turtle · coding-agent-harness-comparison-pi-opencode-claude-codex-grok-4-5-1.ttl

This page · coding-agent-harness-comparison-pi-opencode-claude-codex-grok-4-5-1.html

Skills used

rdf-infographic-skill

Generation environment

Grok 4.5 · Grok CLI (Grok Build TUI)

macOS · rdflib parse + harness validation

Linked Data runtime

URIBurner (Virtuoso-backed)

OpenLink Virtuoso

Named graphs

Document base · Grok share namespace

DAV load target · DAV/demos/daas/coding-agent-harness-comparison-pi-opencode-claude-codex-grok-4-5-1.ttl

Resolver pattern

URIBurner describe

https://linkeddata.uriburner.com/describe/?url={uri}

Extraction provenance

Entities and narrative derived from the companion Turtle graph (Playwright-extracted Grok share → kg-generator → rdf-infographic-skill). Graph payload embedded at generation time for offline exploration.