1 · Mechanism by Mechanism

This chapter takes four core problems and looks at how each system answers them. Every section follows the same shape: what the problem is → the two solutions → where the difference comes from.

1.1 Context Management

The problem

A large language model has a “context window” — there is a hard limit on how much text it can look at in one go. The longer the conversation, the more of it is used up, until nothing more fits. And every turn re-sends the entire history, so long context isn't just “it will fill up” — it's “every turn burns money.”

Claude Code: a five-rung ladder

The point of the five rungs is that each rung loses more information and costs more to run than the one before it. The system always starts with the gentlest tool and only escalates when that isn't enough.

On top of this there's a private Anthropic capability, cache_edits: delete specific content from the cache server-side while the local message list stays completely untouched. This lets “compaction” happen without breaking the prompt-cache prefix — a capability outside developers can't get.

Hermes: a pluggable engine

class ContextEngine(ABC):        # a 490-line abstract base class
    def should_compress(...)      # abstract: is it time to compress?
    def compress(...)             # abstract: how to compress
    def select_context(...)       # abstract: which messages to send this turn

Hermes doesn't prescribe a compaction strategy; what it prescribes is “what a compressor has to look like.” It ships a default implementation called compressor, and you can swap in your own through config.

It also splits the action into two orthogonal verbs:

Where the difference comes from

1.2 Permissions and Safety

The problem

An agent runs commands, edits files, and makes network requests. How do you stop it from doing irreversible damage?

Claude Code: a 10-step cascade

Every tool call goes through a 10-step decision chain. The most important design element is “bypass immunity”:

Hermes: red lines + environment isolation

The first layer is 12 hard-coded red lines (HARDLINE_PATTERNS), backed by a fairly sophisticated parser:

The second layer is the execution environment: 7 backends (local / Docker / Modal / Vercel / Daytona / Singularity / SSH). This is the only true hard boundary — every rule above is “guessing whether this command is dangerous”; only isolation is “even if it is, it can't get out.”

Where the difference comes from

1.3 Multi-Agent

Claude Code: three forms

Those 4 fork-caching tricks deserve a separate mention: for the subagent's request prefix to be identical to the parent's byte for byte, the system has to guarantee that the system prompt, tool definitions, tool ordering, and message serialization are all exactly the same. A single differing byte invalidates the whole cache and multiplies the cost several times over.

Hermes: delegation + kanban

MAX_DEPTH = 1                          # only one level allowed
_DEFAULT_MAX_CONCURRENT_CHILDREN = 10  # at most 10 concurrent
_RECENT_SUBAGENTS_CAP = 200            # cap on the history record

Plus runtime controls: interrupt_subagent (interrupt) / steer_subagent (inject instructions) / set_spawn_paused (stop spawning but let the existing ones finish).

The other mode is kanban: several peer agents share one task board and each claims work from it. Paired with the kanban_heartbeat heartbeat — a task that was claimed and then died automatically goes back to unclaimed.

Where the difference comes from

1.4 Extension Mechanisms

A pattern both use: progressive disclosure

1.5 One-Page Cheat Sheet