Codex vs Claude Code vs OpenCode vs Pi vs Oh My Pi vs Hermes: Which Agent Fits Whom

Six agent names dominate the terminal right now: Codex, Claude Code, OpenCode, Pi, Oh My Pi, and Hermes. They look interchangeable in a demo screenshot because every one of them reads files, edits, runs commands, and opens a pull request. But they answer one question differently: how much of the agent loop does the tool decide for you, and where are you allowed to talk to it from?

Ordered from lightest to heaviest, the lineup is: Pi is a radically minimal terminal loop you extend yourself. Oh My Pi takes that loop and wires an IDE into it. OpenCode is the open-source, any-provider workhorse with a desktop app. Codex is OpenAI's vertical stack, with cloud sandboxes and phone control. Claude Code is Anthropic's polished, closed harness. And Hermes is not really a coding agent at all: it is a persistent personal agent from Nous Research with memory, a learning loop, and gateways to 20+ messaging platforms including Telegram and Signal.

This post ranks them by weight, compares capabilities, and then takes the question most comparisons never answer: which of these can you actually run remotely, which can you drive from your phone without SSH, and which work from Telegram or Signal.

The short version

• Pi is the core. The terminal coding agent now owned by Earendil (pi.dev, MIT) — created by Mario Zechner, acquired in April 2026 with Zechner still at the helm: read, write, edit, and bash at the center, TypeScript extensions for everything else, four modes (interactive, print/JSON, RPC, SDK), and mid-session model switching across 30+ providers. No LSP, browser, or debugger out of the box.
• Oh My Pi (omp) is Pi with the batteries you wished it had. A fork by Stencil Labs (can1357/oh-my-pi, MIT, roughly 36k GitHub stars): LSP wired into every write, a real debugger (DAP), first-class subagents, a critic model watching every turn, 31 built-in tools, its own browser tool and agent-curated memory, 60+ providers, and native Windows support.
• OpenCode is the open horizontal bet. Open source, TypeScript, any of 75+ providers through standard abstractions, a Tauri desktop app, background subagents, and no cloud dependency. The trade is a more manual setup and no foundation model of its own, though its first-party Zen and Go model gateways have started to fill that gap.
• Codex is the vertical bet. A fast Rust CLI with strong defaults, a Chrome extension, kernel-level sandboxing, and the part nobody else matches at scale: cloud tasks in a managed sandbox plus Codex Remote, which puts a connected Mac or Windows host under the ChatGPT mobile app (generally available since June 2026).
• Claude Code is the polished closed harness. Tuned for Claude models, MCP-native, asks before it acts, and runs everywhere Anthropic puts it: terminal, VS Code, JetBrains, desktop, the web at claude.ai/code, mobile via Remote Control with push notifications, and Telegram, Discord, and iMessage through Channels (research preview).
• Hermes is the odd one out on purpose. An always-on personal agent that self-hosts on a cheap VPS, persists cross-session memory, writes reusable skills, and is reachable from 20+ messaging platforms. You would code with it on purpose only if the messaging-first workflow is the point.
• Remote use splits the field cleanly. Codex and Claude Code give you first-party cloud and phone surfaces. OpenCode runs a headless server and web UI you can reach over the network; Pi and Oh My Pi live in a tmux pane you SSH into. Hermes is the only one built messaging-first, and the only one that answers on Signal: Claude Code's Channels cover Telegram and Discord in a research preview, but only while a session is running.

Pi: the minimal loop

Pi, created by Mario Zechner and owned by Earendil since April 2026 — Zechner joined as a major Earendil stakeholder and still runs the project — is the terminal agent taken to its logical minimum. The core tools are read, write, edit, and bash. Everything else is a TypeScript extension you install or write: skills, prompt templates, themes, MCP bridges. Four modes ship with it: interactive, print/JSON for scripting, RPC for programmatic control, and an SDK for embedding it in something bigger. It is MIT-licensed and bring-your-own-model across many providers, with model switching mid-session.

The virtue is that nothing is hidden: the loop is fast, the context is yours, and the total surface is small enough to hold in your head. The cost is equally explicit. No LSP integration, no browser, no debugger in the box, and getting the most out of it means writing extensions. Pi is a power-user tool by design. If you want the smallest loop that is still a real agent, this is it.

Oh My Pi: Pi with the IDE wired in

Oh My Pi is what happens when someone forks Pi and refuses to accept 'you can add that as an extension' as an answer. Built by Stencil Labs on a Rust core (roughly 80k lines per the README, MIT license), it keeps Pi's personality but ships 31 built-in tools, 14 LSP operations, 28 debugger operations, and bindings for grep, shell, images, and syntax highlighting. Standout behaviors: LSP diagnostics wired into every write so the agent sees compile errors immediately, subagents as first-class citizens, an optional second model that reviews every turn, code review with prioritized findings and a verdict, editing by content hash so the agent targets exact text, a built-in browser tool, and agent-curated memory that carries facts and lessons between sessions.

It is complete and opinionated: 60+ providers with mid-session switching, native Windows support, a /collab link that opens your live session in a teammate's browser, and install with one curl line. If Pi is a frame kit, Oh My Pi is the touring version of the same motorcycle. Pick it when you like Pi's loop but want IDE-grade feedback (compile errors, debuggers, review) without writing the extensions yourself.

OpenCode: provider freedom, no lock-in

OpenCode is the open-source horizontal play: TypeScript, no single vendor behind it, and any major provider through standard abstractions, so model routing, caching, and cheap-model mixing are all in your hands. It has a Tauri desktop app, background subagents that keep working while you do other things, a repo research agent, and a client-server core: opencode serve runs a headless HTTP API and opencode web adds a browser interface, so a session on your box is reachable from other devices. Community sentiment consistently lands in the same place: the better power-user tool once you accept more setup, because the flexibility compounds over a high-control workflow.

The honest trade is that OpenCode has no foundation model of its own — its first-party Zen and Go gateways route to other labs' models rather than replacing that layer — plus no first-party cloud and a more manual configuration surface. You are trading Codex's polish and defaults for control and cost. If your workflow already assumes you will pick models per task and audit what the agent does, this is your middle weight.

Codex: the vertical stack

OpenAI's Codex is where vertical integration shows. A Rust CLI with a tight, fast, low-bloat loop and strong defaults, frequent releases, and an ecosystem that stays readable because so much ships tuned and preinstalled. The differentiators are infrastructure: a Chrome extension for browser tasks, kernel-level sandboxing, sandboxed cloud tasks where you fire off long jobs and walk away, a goals system, and Codex Remote — generally available since June 2026 — which puts a connected Mac or Windows host, not just cloud sandboxes, under the ChatGPT mobile app. It remains the closest any of these comes to a first-party 'check on the agent from your phone' experience.

The trade is the OpenAI ecosystem: the models and the managed cloud are proprietary, and using anything else is second-class. If you want least friction, strongest defaults, and infrastructure that handles long-running jobs asynchronously, Codex wins the daily-driver question for most people. If you want to route arbitrary providers or audit every layer, it does not.

Claude Code: the polished closed harness

Anthropic's Claude Code is the most polished way to let a Claude-class model act in your repo. It reads your codebase, edits across files, runs tests, and commits, and it runs in the terminal, VS Code, JetBrains, a desktop app, the web at claude.ai/code, on mobile via Remote Control (claude.ai/code or the mobile app steering a session on your own machine, with push notifications), and through Channels, a research preview since v2.1.80 in March 2026 that pipes Telegram, Discord, and iMessage into a running session. It is MCP-native, asks before destructive actions, and gets the deepest model-harness support because Anthropic writes both halves. Two caveats on the newer surfaces: Channels only receive events while the session is running, and they stay blocked on Team and Enterprise plans until an admin enables them.

The trade is the flip side of that depth: it is closed, tied to Claude models, and priced accordingly. If you already trust Claude for code and want the smoothest path from prompt to merged PR across terminal, web, and phone, this is still the default answer. Note that the harness discipline it established (skills, CLAUDE.md, permission prompts) is portable: Pi-style extension systems, including Oh My Pi and Hermes, deliberately speak a compatible ideas language.

Hermes: the personal agent

Hermes is the outlier in this list because coding is not its core job. It is Nous Research's always-on personal agent: self-hosted, MIT-licensed, running from a cheap VPS, with persistent cross-session memory, a learning loop that turns repeated work into reusable skills, and reachability from 20+ messaging platforms including Telegram, Signal, Discord, and Slack. Bring-your-own-model with first-class support for Nous Portal, OpenRouter, OpenAI, Anthropic, and any OpenAI-compatible endpoint.

That changes what 'remote use' means entirely. You do not SSH into a machine; you message the agent, it does the task with its accumulated context, and it reports back in the same thread you are already in. It can write code, and community setups pair it with the coding agents above rather than instead of them. Choose Hermes when the point is a compounding assistant in the messaging surface you already live in; choose Pi, Oh My Pi, OpenCode, Codex, or Claude Code when the point is sitting inside a repo.

Capability table, light to heavy

Remote use: from the office and from the beach

The hidden axis in every one of these comparisons is where the agent is reachable from, and it splits three ways.

tmux over SSH: Pi, Oh My Pi. The CLI harness runs inside a tmux pane on the box that holds the code, so you SSH in, attach, interact, detach, and walk away while the agent keeps going. This works from a laptop and a surprisingly capable mobile terminal client, with one caveat: two simultaneous writers to the same tmux session turn the transcript into noise, so keep an eye on it. Oh My Pi softens the pain with a shareable session link that lets someone land inside your session without configuring a terminal.

First-party remote surfaces: Codex, Claude Code. Codex pairs sandboxed cloud tasks with Codex Remote, so the agent keeps a long task alive — on a managed sandbox or on a connected Mac or Windows host — while you steer it from the ChatGPT mobile app. Claude Code counters with Remote Control: claude.ai/code or the mobile app steering the session on your own machine, push notifications included. These two have the deepest first-party phone surfaces, with OpenCode's serve/web interface and Oh My Pi's browser-joinable collab links closing part of the gap from the open-source side.

Messaging-first: Hermes. A persistent agent on a VPS, natively reachable from Telegram, Signal, Discord, Slack, and others. You send a message in the channel you already use, and the agent answers with its persistent memory intact. This is not the same as remote-controlling a coding harness: Hermes' memory, skill loop, and chat-native interface are designed for delegation and reporting, not for interactive repo work. Claude Code's Channels research preview now reaches Telegram and Discord too, but it needs the session already running, needs a claude.ai login, stays admin-blocked on Team and Enterprise plans, and does not cover Signal. If you want chat-driven agent access rather than remote terminal access, Hermes is still the supported default: always-on, and the only one here that answers on Signal.

A practical pattern: keep Oh My Pi (or Pi) as the interactive repo tool in tmux for machine-side work, and run Hermes on the same or a neighboring VPS as the always-on assistant you ping from Signal. Community setups treat the coding agents and Hermes as a stack rather than a rivalry; 'run both' is the genuinely common answer among power users.

Which is best for whom

• Choose Pi when you want the leanest, fastest terminal agent there is, you are happy to write or install extensions, and you want full control over context and models.
• Choose Oh My Pi when you want Pi's loop but refuse to build the IDE yourself: LSP feedback on every write, debugger operations, subagents, and an optional critic model out of the box.
• Choose OpenCode when model freedom, cost optimization (routing, caching, cheaper models), and auditability outrank polish, and you accept manual setup in exchange.
• Choose Codex when you want the least-friction daily driver with strong defaults, kernel-level sandboxing, and async cloud jobs you can check from your phone.
• Choose Claude Code when you are Claude-native, want the most polished harness across terminal, web, and mobile, and are fine with closed models at their price.
• Choose Hermes when the destination is a persistent assistant that compounds knowledge about you and answers in Telegram or Signal, not when the destination is sitting in a repo.

The honest limits

• This is a capability comparison, not a benchmark. Terminal agents differ mostly on defaults, tool wiring, and operational shape; a benchmark score from one harness says little about your stack, and I will not invent rankings. Community sentiment is real but varies by week.
• These move fast, in weeks not quarters. Versions, star counts, and feature lists were checked during drafting, and Oh My Pi changed its contribution policy between README revisions. Reconfirm anything you pin here.
• Model bundles and lock-in change every other month, and that reshapes the cost picture repeatedly. Fast-moving pricing claims are why the table above sticks to architecture rather than pricing tiers.
• Hermes vs the rest is partly a category question. Comparing a personal agent to coding harnesses flatters one half of the test; the honest framing is whether the messaging surface beats the terminal experience for how you actually work.

Versions checked

FAQ

Can I drive a coding agent from Telegram or Signal?

It changed in March 2026. Claude Code ships Channels as a research preview (v2.1.80+): first-party plugins push Telegram, Discord, and iMessage messages into a running session. Signal is still not supported, the session has to be running to receive events, and Team and Enterprise plans stay blocked until an admin enables it. For phone control without chat apps, Claude Code's Remote Control and Codex Remote give first-party app surfaces — Codex's steers a connected Mac or Windows host. Hermes remains the native messaging-first answer: built as a persistent agent reachable on 20+ platforms including Telegram and Signal. Pi, Oh My Pi, and OpenCode stay terminal-first: SSH into tmux, with OpenCode's web UI and Oh My Pi's shareable session links as the browser escape hatches.

Do skills and config travel between these tools?

The skills format popularized for Claude Code transfers further than people expect: skills authored for it generally work in Codex, in Pi-style extension systems, and in Hermes, since the format is a directory of instructions rather than a proprietary binary. Prompt files and CLAUDE.md-style context travel more easily than habits do, and far more easily than browser extensions or MCP wiring.

Is Oh My Pi just Pi with a theme?

No. Oh My Pi is a substantial fork with its own Rust core, 31 built-in tools, LSP and debugger operations, a critic model, and its own release process under Stencil Labs. It is Pi-compatible in spirit and much heavier by construction.

What do they cost?

Pi, Oh My Pi, OpenCode, and Hermes are free and open source with bring-your-own-model, so spend goes to model calls. Codex and Claude Code are subscription-first products where the agent is bundled with the model subscription. Pricing tiers change monthly and are deliberately not tabled here.

Further reading

• Oh My Pi on GitHub: https://github.com/can1357/oh-my-pi
• Pi coding agent: https://pi.dev/
• OpenCode: https://opencode.ai/
• Codex CLI: https://developers.openai.com/codex/cli/
• Claude Code: https://anthropic.com/product/claude-code
• Hermes Agent vs Pi overview: https://standardcompute.com/best-ai-agent/hermes-agent-vs-pi
• Hermes Agent docs (Nous Research): https://hermes-agent.nousresearch.com
• Claude Code Channels docs: https://code.claude.com/docs/en/channels

Which one runs your terminal, and what decided it: minimalism, model freedom, polish, or the chat-app surface? If you run two of them as a stack, tell me how. Drop it in the comments.

Until next time, keep your systems thoughtful.