How these coding agents are actually built

Bespoke terminal kernels

Claude Code, Crush, and Codex feel like software products first. Tool schemas, permissions, terminal UX, and recovery behavior are baked into the runtime rather than bolted on through a generic orchestration layer. Crush is uniquely notable for shipping native LSP integration (diagnostics and symbol references) and Sourcegraph code search as first-class built-in tools. Codex stands out as a Rust-native binary built around a Ratatui TUI, organized as a 70+ crate Cargo workspace, with platform-specific sandboxes (Seatbelt on macOS, bubblewrap on Linux, Windows tokens).

Provider-matrix CLIs

Mux, Neovate, and Qwen Code invest heavily in model registries, provider catalogs, and config resolution. The runtime exists partly to normalize many providers into one interface.

Protocol-heavy adapters

Pochi and Kimi CLI are notable for bridge code: MCP adapters, ACP translation, vendor packages, and importers from adjacent ecosystems.

Sandbox and orchestration platforms

DeerFlow and OpenHands focus on multi-step execution environments. They care about app servers, middleware, sandboxes, and delegating work as much as a single interactive CLI session.

Self-improving multi-platform agents

Hermes (Nous Research) is in a category of its own: persistent skill learning, multi-platform messaging gateways, RL training pipelines, and a MoA synthesis tool. Not a coding-only agent, but the most feature-rich architecture in the set.

Claude Code — 10 terminal states, 8 continue reasons

The query engine (src/query/transitions.ts) is a named state machine with explicit exit reasons. Terminal exits: 'completed', 'blocking_limit', 'image_error', 'model_error', 'aborted_streaming', 'aborted_tools', 'prompt_too_long', 'stop_hook_prevented', 'hook_stopped', 'max_turns'.

Continue reasons (agent loops back): 'tool_use', 'reactive_compact_retry', 'max_output_tokens_recovery', 'max_output_tokens_escalate', 'collapse_drain_retry', 'stop_hook_blocking', 'token_budget_continuation', 'queued_command'. Each is a distinct named transition, not a generic "keep going" flag. Token budget fires at COMPLETION_THRESHOLD = 0.9; if per-check delta falls below DIMINISHING_THRESHOLD = 500 tokens three times, the agent is considered complete.

OpenHands — Temperature bumping on dead LLM responses

OpenHands' retry mixin (openhands/llm/retry_mixin.py) uses the tenacity library with a documented intentional quirk: on LLMNoResponseError when temperature is 0, it automatically sets temperature = 1.0 on the next attempt.

The reasoning: a fully deterministic model (temp=0) that returns nothing is stuck in a degenerate fixed point and will return nothing again. Adding randomness breaks the loop. This is one of the more thoughtful LLM retry patterns in the set — it adapts the request rather than just retrying identically.

DeerFlow — 200-line buckets to prevent false loop detection

DeerFlow's LoopDetectionMiddleware hashes tool name + input + output to detect repetition. But for read_file, line numbers are bucketed into 200-line groups before hashing — because paginated file reads of the same file look identical to the naive algorithm, but are legitimate progress.

On warn (3 repeats): inject HumanMessage("you are repeating yourself — wrap up"). On hard limit (5 repeats): strip tool_calls entirely from the response, forcing a plain-text answer and ending the loop definitively.

Qwen Code — Truncation recovery with Levenshtein validation

When the model's response is truncated mid-tool-call, Qwen Code (coreToolScheduler.ts) injects TRUNCATION_PARAM_GUIDANCE ("your previous response was truncated due to max_tokens…") to ask the model to retry, and returns TRUNCATION_EDIT_REJECTION ("tool call has been rejected to prevent writing truncated content") for any edit tool where the output is incomplete.

The scheduler imports both diff and fast-levenshtein to verify that proposed file edits are not corrupted: if a diff-patch looks syntactically valid but the Levenshtein distance between the "before" and "after" is implausible, the edit is rejected. modifiable-tool.ts additionally lets tool calls be edited in-flight by the user before execution.

Claude Code

Recovery is systemic: permissions, retries, tool-specific controls, command systems, and a dedicated runtime all participate. It feels designed around failure as a normal operating condition.

Neovate Code

Strong at pre-emptive failure avoidance. Its shell code tries hard to stop dangerous or malformed commands before they ever run, and its MCP manager tracks retries and connection state explicitly.

Qwen Code

Particularly good at configuration and state management. Model resolution has source precedence, runtime snapshots, and rollback-ish handling that makes the system easier to reason about.

DeerFlow

Uses middleware to absorb failure modes: clarification interrupts, dangling tool-call handling, summarization, and subagent limits. That is framework-style robustness rather than CLI-style robustness.

Crush

Calm, explicit Go-style error boundaries. Provider metadata caching and service organization make failure paths easier to trace than in sprawling dynamic runtimes.

Kimi CLI

More honest than flashy: the ACP docs document current limitations, which is often a sign of a healthy protocol mindset rather than a polished marketing wrapper.

Pi Mono

Error handling is multi-layered: tool-level errors return isError: true to the LLM for self-retry, abort signals trigger graceful cleanup (temp files closed, partial results returned), compaction failures auto-retry, and extension errors are caught and emitted via emitError() without crashing the agent. The file mutation queue prevents concurrent write races entirely.

Codex

Strict clippy configuration denies unwrap_used and expect_used across the workspace, forcing explicit error handling at compile time. Runtime recovery includes a 300s idle timeout and up to 5 stream retries before giving up.