Brain-Hands Decoupling

concept Apr 9, 2026

ai-agentsarchitecturedecouplingseparation-of-concerns

An architectural pattern for agent systems that separates reasoning (the “brain”) from execution (the “hands”) and state (the “session”) into independently replaceable components behind stable interfaces.

The pattern

Three components, each behind a minimal interface:

Component	Role	Key interface	Failure mode
Brain	Claude + harness loop	`wake(sessionId)`	Reboot, replay from session log
Hands	Sandboxes, tools, MCP servers	`execute(name, input) → string`	Catch error, provision new sandbox
Session	Append-only event log	`emitEvent()`, `getEvents()`	Durable storage, survives both

The brain calls the hands the way it calls any other tool — through a uniform interface. It does not know whether the sandbox is a container, a remote VPC, a phone, or any other execution environment. The session sits outside both, providing durability and recoverability.

Why decouple

Coupled systems create “pets” — named, hand-tended individuals that can’t be lost. When the brain and hands share a container: if the container fails, the session is lost; if it’s unresponsive, operators must debug inside a container holding user data; and connecting to new infrastructure (e.g., a customer’s VPC) requires network peering because the harness assumes co-location.

After decoupling, every component is “cattle” — interchangeable and replaceable. The brain is stateless (session lives elsewhere). The hands are provisioned on demand. The session persists independently.

Relationship to OS design

The analogy is explicit in the source: operating systems virtualized hardware (disk, memory, CPU) into abstractions (file, process) general enough for programs that didn’t exist yet. The read() system call is agnostic to whether it’s reading a 1970s disk pack or a modern SSD. Brain-hands decoupling virtualizes agent components the same way — the execute() call is agnostic to what runs behind it.

Connections

Managed Agents Architecture: the system that implements this pattern
Meta-harness: the design philosophy that motivates decoupling
Hermes Agent takes the opposite approach — a single process with 6 terminal backends. This works for a developer tool but limits infrastructure flexibility
Capsules: isolated environments for agents — the “hands” in this pattern
The user notes that the boundary between software and hardware is an implementation detail — brain-hands decoupling embodies this: the brain’s interface abstracts away whether the hands are software containers or physical devices

Backlinks

Building Effective Agents

Directly extends the Managed Agents Architecture by the same organization — that post covers infrastructure, this one covers design patterns

The brain-hands split in Brain-Hands Decoupling is the infrastructure counterpart to the augmented LLM concept here

The orchestrator-workers pattern maps to the "many brains, many hands" idea in Managed Agents

The ACI concept connects to tool design patterns in Hermes Agent and OpenClaw

→

Agent-Computer Interface

The execute(name, input) -> string interface in Brain-Hands Decoupling is an ACI — simple, uniform, hard to misuse

Hermes Agent's 40+ tools with typed schemas and dispatch loop are a large-scale ACI implementation

Agent Exec Policy adds a safety layer on top of the ACI — controlling which tool calls are approved

The poka-yoke principle connects to Robustness Control — designing systems that resist failure modes rather than detecting them after the fact

The emphasis on absolute paths over relative paths mirrors standard software engineering practice and is enforced by tools like Claude Code

→

Agentic Workflow Patterns

Augmented LLM is the building block that all five patterns compose

The orchestrator-workers pattern parallels the Brain-Hands Decoupling in Managed Agents — one brain, many hands

The evaluator-optimizer loop is structurally the same as the Agent Learning Loop — generate, evaluate, refine

CORAL implements a sophisticated version of orchestrator-workers with shared memory and asynchronous co-evolution

Hermes Agent's skill creation after complex tasks resembles the evaluator-optimizer: generate a solution, evaluate it, refine into a reusable skill

→

Augmented LLM

The "brain" in Brain-Hands Decoupling is an augmented LLM — Claude plus harness loop, with sandboxes as the tools

Hermes Agent is a concrete implementation: Claude + 40 tools + FTS5 memory + skills = one augmented LLM in a chat loop

Context Window Compression addresses the memory augmentation — what happens when the model's retained state exceeds capacity

The concept connects to the LLM wiki pattern in LLM Knowledge Bases where the retrieval augmentation is a structured wiki rather than raw documents

→

Channel Adapter Pattern

Multi-Channel AI Gateway — the broader architecture this pattern enables

Brain-Hands Decoupling — adapters are the "hands" behind stable interfaces

→

Building Effective Agents

The infrastructure counterpart to this design guide is Managed Agents Architecture by the same organization — that post covers the brain/hands/session split, this one covers the patterns running inside the brain

The orchestrator-workers pattern directly maps to the "many brains, many hands" architecture in Brain-Hands Decoupling

The emphasis on tool quality resonates with Hermes Agent's 40+ tools and skill system — both argue that tool design matters more than prompt design

The evaluator-optimizer pattern is structurally identical to the Agent Learning Loop: generate, evaluate, improve

The recommendation to start simple and add complexity connects to the knowledge base's theme around Autonomy With Acceptable Quality

→

Managed Agents Architecture

The meta-harness concept: opinionated about interfaces, not implementations

Harness staleness: why harnesses need to be swappable

Brain-hands decoupling: the core architectural pattern

Hermes Agent takes a different approach — bundling terminal backends, memory, and skills into a single agent process, though its 6 terminal backends (local, Docker, SSH, Daytona, Modal, Singularity) parallel the "many hands" idea

Context window compression: the session-as-context-object pattern is an alternative to summarize-and-discard

Credential pool pattern: solves a related problem (safe credential access) with a different mechanism (failover rotation vs. vault isolation)

The user's observation that an AI agent is always physical — Managed Agents makes the brain/hands split explicit, treating execution environments as abstract "hands" regardless of substrate

→

Meta-Harness

Managed Agents Architecture: Anthropic's implementation of the meta-harness concept

Brain-hands decoupling: the architectural pattern that makes the meta-harness possible

Harness staleness: the problem the meta-harness solves

→

AI Agents

Capsules Isolated Environments for AI Agents — isolated, reproducible environments for agents

Clawdbot Capsules and Self Evolving Agents — minimal core + self-development

My Digital Twin Starts With Claude Code — personal knowledge graph from Claude Code sessions

Hermes Agent — self-improving multi-platform agent framework with learning loop, skills, and RL training (Nous Research)

OpenClaw — personal AI assistant gateway: 24+ messaging channels, typed plugin adapters, embedded agent runtime, native companion apps

Agent Learning Loop — memory + skills + session search forming a closed self-improvement cycle

Sleep-Phase Memory Consolidation — offline three-phase (light/REM/deep) memory consolidation with evidence accumulation thresholds

Context Window Compression — auto-summarizing old conversation turns to stay within context limits

Credential Pool Pattern — multi-credential failover with selection strategies for agent infrastructure

Managed Agents Architecture — Anthropic's hosted long-horizon agent service: brain/hands/session decoupling

Brain-Hands Decoupling — separating reasoning from execution behind stable interfaces

Meta-Harness — system designed for harnesses that don't exist yet

Harness Staleness — harnesses encode assumptions that go stale as models improve

Session as Context Object — durable event log as interrogable context outside the context window

Multi-Channel AI Gateway — single-daemon architecture routing one agent across many messaging platforms

Channel Adapter Pattern — typed composition of optional interfaces for messaging channel plugins

→

Multi-Channel AI Gateway

Channel Adapter Pattern — the typed composition approach for individual channel implementations

Brain-Hands Decoupling — the broader principle of separating reasoning from execution

Session as Context Object — durable session model underlying multi-channel routing

→

Orchestrator-Workers Pattern

The Managed Agents Architecture is the infrastructure for this pattern at scale — the brain (orchestrator) calls many hands (workers) through execute(name, input) -> string

Brain-Hands Decoupling formalizes the interface between orchestrator and workers

CORAL extends this into autonomous multi-agent evolution — agents act as both orchestrators and workers, with shared persistent memory replacing explicit delegation

Cross-Agent Knowledge Transfer describes what happens when workers can learn from each other's results, which the basic pattern doesn't include

The user's blog post From Solo Sessions to Agent Orchestras describes the human experience of scaling from a single agent to an orchestrated team — the human becomes the orchestrator

→

OpenClaw

Architecturally parallel to Hermes Agent: same multi-platform gateway + skills + tools + session pattern, different language (TypeScript vs Python) and different design philosophy (composition-based adapters vs inheritance-based ABC). OpenClaw has stricter plugin boundaries and a richer native companion app story; Hermes Agent has a built-in learning loop and RL training infrastructure.

The channel adapter pattern is a typed variant of the plugin composition approach described in managed agents architecture — tools and capabilities compose without inheritance.

Skills system parallels Hermes Agent's SKILL.md format and the agent learning loop pattern, though OpenClaw's skills are not self-created by the agent (they're authored by users or shipped by plugins).

The gateway-as-control-plane design echoes the brain-hands decoupling pattern: reasoning (agent runtime) and execution (channel adapters, tool backends, nodes) are separated behind stable typed interfaces.

Context compaction mirrors context window compression — auto-summarizing when approaching limits, preserving recent context, keeping cached prefixes stable. OpenClaw adds staged summarization for large histories and an identifier preservation policy.

The dreaming system (memory-core plugin) implements sleep-phase memory consolidation — three-phase offline consolidation (light/REM/deep) with evidence accumulation thresholds before durable promotion. This is the offline complement to the agent learning loop.

Tool loop detection uses content-aware result hashing to distinguish legitimate polling from stuck loops, with four independent detectors and escalating response (warn -> critical -> circuit break).

The agent exec policy implements three-axis human-in-the-loop tool approval (security x ask x fallback) with fail-closed composition across host and session policies.

Two-tier model failover extends the credential pool pattern: auth profile rotation (inner loop) + model fallback chain (outer loop) + cooldown probing near expiry.

→