Skip to content

# Agent CLI Reference: 5-Tool Comparison ​

A side-by-side reference for Claude Code, Pi Coding Agent, OpenCode, Hermes Agent, and OpenClaw.

## 1. Claude Code (Anthropic) ​

Role: Primary generalist coding agent. Best all-around tool.
License: Proprietary (free tier + Pro subscription)
Runtime: Node.js
Config: `CLAUDE.md` in project root

### Key Capabilities ​

Feature | How To | Course Reference
--- | --- | ---
Multi-agent teams | `claude --teammate-mode tmux` | M4 — teammate-mode spawns agents in split panes
Headless execution | `claude -p "prompt" --print` | M5 CI/CD pipeline
Constrained tools | `--allowedTools "Read Write Edit"` | M3 security (L4 whitelist pattern)
Hooks system | `.claude/hooks/*.py` | M3 hook architecture (13 lifecycle events)
Subdirectory rules | `frontend/CLAUDE.md`, `backend/CLAUDE.md` | M2 skills deep dive
Stop hook self-improve | PostToolUse → headless claude session | M3, also ClaudeFAST pattern

### Boilerplate Setup ​

bash

    # Project initialization
    claude --init

    # Launch with teammate mode
    claude --teammate-mode tmux

    # Headless CI mode
    claude -p "Implement the feature described in spec.md" --allowedTools "Read Write Edit Bash" --print

    # With custom hooks directory
    claude --hooks .claude/hooks/

### Hook Lifecycle (13 events) ​

Phase | Events
--- | ---
Session | Setup, SessionStart, SessionEnd
Main Loop | UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PostToolUseFailure, Stop, Notification
Subagents | SubagentStart, SubagentStop
Maintenance | PreCompact

## 2. Pi Coding Agent (pi.dev) ​

Role: Customizable agent harness. Full control over every aspect.
License: Open source (MIT)
Runtime: Node.js (TypeScript SDK)
Config: `.pi/settings.json`, `.pi/agents/*.md`

### Key Capabilities ​

Feature | How To | Course Reference
--- | --- | ---
Extensions | `pi -e extensions/<name>.ts` | M3 — damage-control, tilldone
RPC mode | `pi --mode rpc` | M5 — programmatic control (26+ commands)
Agent teams | `agent-team` extension + `teams.yaml` | M4 dispatcher pattern
Agent chains | `agent-chain` extension + `agent-chain.yaml` | M4 pipeline pattern ($INPUT/$ORIGINAL)
P2P communication | `coms` (Unix sockets) / `coms-net` (HTTP/SSE) | M4 flat P2P pattern
Mental models | `.pi/multi-team/expertise/*.yaml` | M4 agent memory, self-improve commands
Damage control | `damage-control.ts` + `damage-control-rules.yaml` | M3 three access levels
Skills system | `.pi/skills/*/SKILL.md` | M2 composable skills

### Boilerplate Setup ​

bash

    # Launch with extensions
    pi -e extensions/damage-control.ts -e extensions/tilldone.ts -e extensions/minimal.ts

    # Launch with multiple extensions (stackable)
    pi -e extensions/purpose-gate.ts -e extensions/tool-counter.ts

    # RPC mode (programmatic control from any language)
    pi --mode rpc

    # Pi-to-Pi peer communication (same machine)
    just local-coms --name planner --purpose "Plans the work"
    just local-coms --name coder --purpose "Writes the code"

    # Pi-to-Pi networked (across machines)
    just coms-net-server    # hub
    just coms --name dev    # client 1
    just coms2 --name prod  # client 2

### Extension Catalog (16 total) ​

Category | Extensions
--- | ---
UI | pure-focus, minimal, theme-cycler, session-replay
Monitoring | tool-counter, tool-counter-widget
Task | tilldone, purpose-gate
Multi-Agent | subagent-widget, agent-team, agent-chain
Safety | damage-control, damage-control-continue
P2P | coms, coms-net
Cross-Tool | cross-agent, system-select
Meta | pi-pi

### Pi Agent Rust Port (Jeff Emanuel, 1,024★) ​

A Rust reimplementation of the Pi agent with zero unsafe code.

Feature | Pi (TypeScript) | Pi Agent Rust
--- | --- | ---
Extensions | Full (16+) | Compatible
RPC mode | Yes | Yes
Performance | Baseline | ~2x faster
Binary size | ~35MB | ~8MB
Memory safety | Node.js GC | Zero unsafe Rust

### The 4 Dimensions of Control (Pi's strength) ​

Dimension | Pi's Advantage
--- | ---
Context | Full control over what the agent sees via extensions
Model | Any provider, any model — pluggable
Prompt | Skills, system prompts, agent .md files — fully customizable
Tools | Extensions can add, remove, or override any tool

## 3. OpenCode (opencode.ai) ​

Role: Open-source Claude Code alternative. MIT license.
License: MIT (open source)
Runtime: Node.js (npm global package)
Config: Shares `~/.grok/config.toml` with Claude Code

### Key Capabilities ​

Feature | How To | Course Reference
--- | --- | ---
Headless commands | `opencode run "prompt"` | M5 CI/CD alternative to Claude Code CLI
Model selection | `opencode --model opencode-go/deepseek-v4-flash` | M6 cascade routing
Proxy support | Routes through `localhost:18901/v1` | M6 cost optimization
Shared config | Uses same `~/.grok/config.toml` | M5 production stack — dual tool setup
Go models | 12 Go-optimized models available | M6 economics (Go models are cheaper per token)

### Available Go Models (through proxy) ​

Model ID | Cost Tier | Best For
--- | --- | ---
`opencode-go/deepseek-v4-flash` | Budget | General agentic tasks ($10/mo flat)
`opencode-go/deepseek-v4-pro` | Mid | Complex reasoning
`opencode-go/kimi-k2.6` | Mid | Long context
`opencode-go/qwen3.6-plus` | Budget | Structured tasks
`opencode-go/minimax-m2.7` | Budget | Fast responses

### Boilerplate Setup ​

bash

    # Headless task execution
    opencode run "Refactor the auth module to use JWT tokens"

    # With specific model
    opencode --model opencode-go/deepseek-v4-flash run "Write unit tests for the API"

    # With custom config
    opencode --config ~/.grok/config.toml run "Deploy to staging"

    # List available models
    opencode models

### When to Use OpenCode Instead of Claude Code ​

Scenario | Choose
--- | ---
Need open-source license | OpenCode
Budget-constrained | OpenCode (Go models at $10/mo flat)
CI/CD pipelines | OpenCode `run` command
Primary development | Claude Code (better tool calling)
Need hooks system | Claude Code (13 events vs OpenCode's limited hooks)
Heterogeneous stack | Both (OpenCode as backup/alternative model)

## 4. Hermes Agent (Some Engineering Inc.) ​

Role: TypeScript-native, MCP-first agent for structured workflows.
License: Open source
Runtime: Node.js (TypeScript)
Design philosophy: MCP-native architecture, structured output first

### Key Capabilities ​

Feature | How To | Course Reference
--- | --- | ---
MCP-native tools | Built-in MCP client | M2 Beyond MCP channels
Structured output | TypeScript types enforced | M2 context management
Tool-use workflows | Designed for function-calling chains | M2 agent loop variants
OpenClaw ecosystem | Integrates with OpenClaw agents | M4 multi-agent orchestration

### Boilerplate Setup ​

bash

    # Run with MCP server
    hermes --mcp-servers ./mcp-config.json

    # Execute workflow
    hermes run workflow.ts

    # With custom tools
    hermes --tools-dir ./tools/

### When to Use Hermes ​

- Building TypeScript-native agent pipelines
- MCP-first architecture (tools as MCP servers)
- Tight integration with OpenClaw ecosystem
- Structured output enforcement (TypeScript types)

## 5. OpenClaw ​

Role: Always-on agent employee. Heartbeat-driven, autonomous execution.
License: Open source
Runtime: Node.js daemon
Design philosophy: "If it can receive a heartbeat, it's hired."

### Key Capabilities ​

Feature | How To | Course Reference
--- | --- | ---
Heartbeat model | Wakes on schedule, works, sleeps | M7 always-on agents
One-shot execution | `claw do "task"` | M5 production task dispatch
Device-key pairing | Auth via device key + invite | M5 deployment modes
Paperclip-native | Primary agent for Paperclip orchestration | M7 framework comparison
tmux integration | Can run inside tmux sessions | M5 production stack

### Boilerplate Setup ​

bash

    # Start as daemon (always-on employee)
    claw start --daemon

    # One-shot task
    claw do "Review the latest PR and leave comments"

    # Schedule recurring task
    claw schedule --cron "0 6 * * 1" --task "Generate weekly report"

    # Check status
    claw status

    # Stop daemon
    claw stop

### Heartbeat Execution Model ​

    Timer fires → Check for queued work → Wake agent → Execute → Report results → Sleep

No continuous running. The agent wakes, works, and goes back to sleep. This is the most cost-effective model for scheduled/recurring work.

## Comparison Matrix ​

Feature | Claude Code | Pi Agent | OpenCode | Hermes | OpenClaw
--- | --- | --- | --- | --- | ---
License | Proprietary | MIT | MIT | Open | Open
Cost | Pro sub | Free | Free | Free | Free
Hooks | 13 events | Extension events | Limited | MCP events | None
Multi-agent | teammate-mode | Extensions | No | Chains | Heartbeats
P2P coms | No | coms/coms-net | No | No | No
Headless mode | `--print` | RPC mode | `run` | Yes | daemon
MCP support | Built-in | Via extensions | Via proxy | Native | Via Paperclip
Best for | Generalist coding | Custom harness | OSS alternative | TS pipelines | Always-on tasks
Course module | M3, M4, M5 | M3, M4, M5 | M5, M6 | M5 | M5, M7

## Quick Selection Guide ​

    What are you building?
    ├── A feature? → Claude Code
    ├── A custom workflow? → Pi Agent
    ├── An open-source project? → OpenCode
    ├── A TypeScript pipeline? → Hermes
    └── A recurring task? → OpenClaw

    Need multiple?
    ├── Production system → All 5 (see REFERENCE-STACK.md)
    ├── Budget constrained → OpenCode + Go models
    ├── Maximum control → Pi Agent + extensions
    └── Enterprise rollout → Claude Code + Agent Manager