Agent Comparison

Capstone reference — synthesizing findings from all prior chapters into quick-lookup tables and per-agent profiles.

Overview Matrix

Agent	Language	Interface	Tool Protocol	Session Storage	Edit Strategy	Subagents
Codex	Rust	CLI/TUI (ratatui)	Custom	JSONL	Diff/Patch	No
Cline	TypeScript	VS Code + CLI	Custom	(IDE-managed)	Exact match + Patch	Yes (team)
Goose	Rust	CLI + Electron	MCP-native	SQLite v15	Extension-dependent	Yes (bounded, depth=1)
Grok Build	Rust	TUI (ratatui, out-of-process)	Custom + MCP	SQLite (WAL)	Hashline / Exact match	Yes (goal pipeline)
Kimi Code	TypeScript	CLI/TUI + Web	Custom (kap-server)	JSONL (wire)	Dynamic	Yes (host+batch)
OpenCode	TypeScript	TUI (opentui/Solid) + Desktop	Custom + MCP	SQLite (Drizzle)	Exact match	Yes (sub-session)
Kilocode	TypeScript	TUI + VS Code + JetBrains	Custom + MCP	SQLite (Drizzle)	Exact match	Yes (sub-session)
Pi	TypeScript	CLI/TUI (custom diff-render)	Custom	JSONL (tree)	Exact match	No
Qwen Code	TypeScript	CLI/TUI (ink/React)	Custom + MCP	JSONL	Exact match	Yes (arena/team/workflow)
OpenHands	Python	Web	MCP	(server DB)	(CodeActAgent)	Microagents

Agent	LLM Classifier?	Fast Path	Fail-Closed?
Goose	Yes (single-stage)	`ToolAnnotations.read_only_hint`	Yes
Grok Build	Yes (behind heuristic pre-pass)	Deterministic heuristic + allowlists	Yes
Qwen Code	Yes (two-stage)	Stage 1 cheap boolean	Yes
Codex	No	`is_known_safe_command()` allowlist	Yes
OpenCode/Kilocode	No	Glob-matched static rules	Yes
Cline	No	Mode presets remove tools structurally	N/A

Agent	Paradigm	Concurrency	Resume?
Qwen Code	JS workflow DSL (Turing-complete)	16 concurrent, 1000 total	Yes (journal replay)
Goose	Declarative YAML recipes	5 concurrent delegates	No (restart from scratch)
Grok Build	Harness-driven goal state machine	1–5 skeptics parallel	Yes (state.json, manual)
Kimi Code	Flat spawn/batch	Ramp of 5 + 1/700ms	Yes (resume by agentId)

Agent	Batch Primitive?	Validate-Before-Write?	Rollback?
Codex	Yes (apply_patch)	Yes (full pre-flight)	No
Grok Build	Single-file only	Yes (in-memory compute)	N/A (true atomic per-file)
Qwen Code	Worktree isolation	N/A	Discard worktree
OpenCode/Kilocode	Yes (apply_patch)	Parse-level only	No (documented gap)
Pi / Goose	Sequential calls	No	No

Agent	MCP Role	Transports	Discovery	Auto-Restart
Goose	All tools via MCP	stdio/SSE/HTTP	Eager	Yes (extension lifecycle)
Grok Build	Alongside built-ins	stdio/SSE/HTTP	Eager + meta-tools	Yes (3 retries + backoff)
Qwen Code	Alongside built-ins	stdio/SSE/HTTP	Deferred (tool-search)	Yes (health polling)
Codex	Client + Server	stdio/HTTP	Prewarmed + cached	Best-effort
Cline	Alongside built-ins	stdio/SSE/HTTP	Eager	No (stdio); Yes (HTTP)

Agent	Turn Cap	Loop Detection	Recovery
Goose	1000	RepetitionInspector (disabled)	Stop-hook denial; retry resets conversation
Grok Build	Token budget	Stall counter + gap fingerprint	Strategist subagent; auto-pause
Qwen Code	1000 agents / 30min	Stall watchdog (60s)	Abort workflow
Codex	None (token budget optional)	Guardian denial breaker only	Model self-corrects
Kilocode	25 steps	Compaction-attempt cap (3)	StepLimitExceededError
OpenCode	Infinity (configurable)	None (TODO in source)	Forced text-only turn

Agent	Framework	Process Model	Cancel Mechanism
Grok Build	ratatui	Out-of-process (ACP)	Protocol message
Codex	ratatui	In-process (tokio)	InterruptManager RPC
Qwen Code	ink (React)	In-process	AbortController
OpenCode	opentui (Solid)	In-process	Context/provider abort
Pi	Custom diff-render	In-process	Keybinding-routed
Goose	Styled stdout	In-process	ctrl_c() race in select!
Cline	VS Code webview	Extension host	postMessage cancel

Philosophy: Minimal tool surface, maximum model intelligence
Unique strengths: Custom apply_patch diff language (multi-file in one call), prompt cache prewarm, Starlark-based exec policy, self-as-MCP-server mode
Weaknesses: No turn limits, no doom-loop detection, relies entirely on model judgment + compaction
Crate count: ~15

Philosophy: IDE-native, proactive parallelism
Unique strengths: YOLO mode (autonomous background), plan/act mode toggle, gRPC-style streaming to webview, per-tool MCP auto-approval UI
Weaknesses: No LLM safety classifier, auto-approves all shell commands by default, no auto-restart for crashed stdio MCP servers
Packages: SDK-based (shared, core, llms)

Philosophy: Extension-first, minimal core
Unique strengths: ALL tools via MCP (most modular), recipe/scheduler system with cron, LLM permission judge with prompt-injection defenses, stop-hook denial mechanism
Weaknesses: Retry silently disabled for cron-triggered recipes, SubRecipe.sequential_when_repeated declared but never enforced, no full TUI (styled stdout only)
Crate count: ~12

Philosophy: Rich tool taxonomy, maximum robustness
Unique strengths: Hashline editing (anchor-based, atomic per-file), adversarial goal verification (skeptic panel), out-of-process TUI (ACP), imports Claude/Cursor MCP configs, most layered permission system (heuristic + LLM + policy), custom resilient MCP transport
Weaknesses: Largest codebase (~65 crates), CheckpointChain scheme unshipped, single-file-only atomicity
Crate count: ~65

Philosophy: Enterprise infrastructure, full observability
Unique strengths: DI service layer, transcript system with 4 granularity levels, rate-limit-aware batch scheduler (ramp + backoff + capacity recovery), subagent resume by ID
Weaknesses: No workflow DSL, no orchestration beyond spawn/batch, no filesystem isolation for subagents
Packages: ~12

Philosophy: Type-safe effects, composable services
Unique strengths: Effect-TS throughout, SystemContext registry, shadow-git checkpoint system (message-level undo), opentui/SolidJS renderer
Weaknesses: No LLM safety classifier, OpenCode has no step cap (Infinity default), apply_patch has no rollback (documented gap)
Relationship: Near-identical forks. Kilocode adds 25-step hard cap, compaction guard, VS Code + JetBrains extensions.
Packages: ~30+

Philosophy: Simplicity, hackability
Unique strengths: Smallest codebase with full agent capability, custom differential-rendering TUI, JSONL tree for session branching, cleanest prompt builder
Weaknesses: No orchestration, no MCP, no rollback, no loop detection, opt-in-only git checkpoint (example extension)
Packages: ~6

Philosophy: Feature maximalism, orchestration
Unique strengths: JS workflow DSL (sandboxed, resumable, budget-aware), arena/team multi-agent, deferred MCP tool discovery (tool-search), worktree isolation, two-stage permission classifier with anti-injection, largest tool count (~60+)
Weaknesses: Complexity (shared ancestor with OpenCode means inherited gaps), node:vm sandbox not fully hardened (no isolated-vm)
Lineage: Shares structure with OpenCode/Kilocode

Philosophy: Enterprise platform, integration-first
Unique strengths: Python, microagents with triggers, GitHub/GitLab/Jira/Slack integrations, web-first
Focus: PR automation, issue resolution — not interactive CLI