Fast & Slow Brain
The Dual-Process Split
"Fast brain / slow brain" is informal shorthand for a dual-process split inside an agent, borrowed from Kahneman's System 1 and System 2. Instead of one model handling every event at one speed and one price, the agent runs two loops that differ in latency, cost and depth of deliberation, with something in between deciding which one an event deserves.
The argument is economic as much as cognitive. Running a frontier model over every alert, every turn, every control cycle does not survive contact with production volume. The cheap loop buys coverage; the expensive loop is reserved for the cases that warrant judgement. This is the same reasoning behind the tiered cascade in Judge & Escalation, applied to the agent's own response path rather than only to evaluation.
The two loops are usually decoupled asynchronously. The fast loop keeps responding while the slow loop runs behind it, and the slow loop's output conditions the fast one rather than replacing it, whether as a plan, a belief update or a memory write. That handoff, and the staleness it introduces, is where most of the design difficulty lives.
The Two Systems
Handles the immediate turn: the conversational reply, a retrieval from memory, a reactive control step, a routine classification. Small model, distilled policy, or cached pattern. It runs on every event without exception, which is precisely what makes its unit cost the binding constraint.
Multi-step reasoning, planning, tool orchestration, reflection, belief revision. Frontier model with a large context and a real thinking budget. Invoked on a fraction of events, and its output conditions or updates the fast loop rather than being served directly to the user.
Model Portfolios
The binary is how to learn this, not how to build it at scale. Systems running real volume select from a portfolio of models per task, which exposes a flaw in treating the split as a difficulty threshold: difficulty is not one dimension. These demands are independent, and a task can be severe on one and trivial on the rest.
| Demand | What the Task Needs | Why It Does Not Track Difficulty |
|---|---|---|
| Latency ceiling | A response inside a fixed budget, sometimes a few hundred milliseconds | A trivial lookup and a nuanced judgement can share the same deadline |
| Precision and consistency | The same input to produce the same classification every time | Consistency is a different property from capability, and larger models are not automatically steadier |
| Context length | Dense policy, long history or large documents held without losing the middle | Reading a lot is not the same as reasoning hard about a little |
| Register and tone | Output that sounds warm, on-brand, or appropriately formal | The strongest reasoning model is often not the most natural writer |
| Determinism | Output constrained to a schema or an approved form of words | Wanting less latitude is not wanting less capability |
| Cost tolerance | A unit price the volume can actually sustain | The highest-volume steps are usually the least demanding, which is what makes the portfolio pay |
Routing becomes a lookup on task type rather than a threshold on difficulty. Two systems remain the right starting point, because each additional model adds a failure profile, a version to pin and an evaluation suite.
Split Patterns
The same dual-process idea takes a different shape depending on what the fast loop is protecting: user-perceived latency, a control frequency, a token budget, or an alert queue.
A fast "Talker" synthesises the response from the current belief state while a slower "Reasoner" performs multi-step reasoning, tool calls and planning to produce a new belief state. The Talker never blocks on the Reasoner; it uses whatever belief state is current, and the Reasoner updates it out of band.
A vision-language model acts as System 2, emitting high-level intent at a few hertz, while a lightweight action head runs as System 1 at control frequency. The two explicitly operate at different clock rates; the fast head must stay stable when the slow head is late or silent.
The fast brain processes one hundred percent of incoming events, classifying and enriching them and assembling cases, while the slow brain applies judgement to the subset that survives triage. Slow-brain verdicts are fed back as labels or rules that sharpen the fast brain over time.
A third component, neither of the two solvers, decides which system handles the problem, using confidence, past performance on similar instances, and available budget. Making the arbiter explicit is what distinguishes this from an ad-hoc escalation rule, and it gives you somewhere to measure and tune routing quality.
The fast brain proposes a complete answer and the slow brain verifies or repairs it, rather than the slow brain generating from scratch. Verification is often cheaper than generation, so the expensive model is spent on checking rather than producing. Speculative decoding is this pattern at token granularity.
Handoff Representations
The slow brain has to hand something back that the fast brain can actually use within its latency budget. The choice of representation determines how lossy the handoff is and how badly it ages.
| Representation | What Crosses the Boundary | Fast Brain Consumes It As | Staleness Risk |
|---|---|---|---|
| Belief State | A structured snapshot of what the agent currently believes about the user, task and world | Read directly as context for the next reply, with no interpretation step | Medium |
| Plan / Task List | An ordered set of steps, each executable by the fast loop without further reasoning | Popped step by step until exhausted or invalidated | High |
| Latent Conditioning | An embedding or latent vector, not natural language | Concatenated into the fast policy’s input at every control step | Medium |
| Memory Write | Curated facts, reflections or summaries committed to long-term store | Retrieved on demand at query time, never pushed | Low |
| Policy / Rule Update | A new routing rule, filter or few-shot exemplar derived from slow-brain verdicts | Applied by the fast loop as configuration, not context | Low |
| Verdict / Correction | Accept, amend or reject on an output the fast brain already produced | Applied before release, or as a post-hoc amendment if already streamed | Low |
Routing Signals
Something has to decide whether an event is routine or worth deliberating over. SOFAI calls this the metacognitive module; in production systems it is usually a cheap classifier, a rules layer, or the fast brain itself raising a hand. Routing quality caps the value of the whole architecture: over-route and the cost argument collapses, under-route and the slow brain never sees the cases it exists for.
The cheap model reports how sure it is, and low confidence triggers escalation. The most common signal because it needs no extra inference pass.
Watch for: Small models are systematically overconfident on out-of-distribution inputs, which are exactly the cases you wanted to escalate. Calibrate against held-out labels rather than trusting raw scores.
Route by how far the input sits from anything seen before, using embedding distance from known clusters or the absence of a close memory match.
Watch for: Novelty is not the same as difficulty. Cosmetically unusual but trivially handled inputs will burn slow-brain budget.
Irreversible actions, financial impact, external communication and privileged tool calls go to the slow brain regardless of confidence.
Watch for: Stakes are a property of the action, not the input, so this check has to sit at the tool boundary rather than at intake.
Remaining token or latency budget gates escalation. Under load the router narrows what qualifies as slow-brain-worthy.
Watch for: Degradation must be explicit and observable. Silently downgrading under load produces quality cliffs nobody can explain afterwards.
A turn that requires orchestrating tools is deliberative by definition. Detecting an intent to act is a reliable, cheap escalation trigger.
Watch for: Single trivial lookups do not need a planner. Distinguish one-shot retrieval from genuine multi-step orchestration.
The user asks for reasoning, a plan, or a careful check. The cheapest and most accurate router signal available.
Watch for: Under-used. Many systems route entirely on inferred signals while ignoring the user saying "think about this properly".
Real Implementations
Explicitly frames an agent as a fast, intuitive Talker producing the conversational response and a slower, deliberative Reasoner performing multi-step reasoning, planning and tool use to produce new agent state. Demonstrated on a sleep-coaching assistant where the Talker must stay responsive while the Reasoner works through the coaching plan.
Vision-language-action models built as an explicit two-system stack: a VLM reasoning about the scene and the instruction at low frequency, and a lightweight action head producing motor commands at control frequency. The two run at different rates and are trained to remain coherent across that gap.
A family of architectures pairing fast heuristic solvers with slow deliberative search, arbitrated by an explicit metacognitive module that decides which solver to invoke based on confidence and past performance. Notable for treating the router as a first-class component rather than an escalation rule bolted on afterwards.
The fast brain triages the entire alert stream automatically and assembles cases; the slow brain applies deep judgement to what survives, and its verdicts feed back to sharpen triage. The clearest production statement of the coverage-versus-judgement trade: full coverage is only affordable at the cheap tier.
Failure Modes
The slow brain reasons over a snapshot, and by the time its plan or belief state lands the conversation has moved on or the environment has changed. The fast loop then acts confidently on a stale premise.
Fix: Version every handoff against the state it was derived from and have the fast loop discard outputs whose premise no longer holds. Prefer belief updates over step-by-step plans, which age faster.
The slow brain’s reasoning is rich, but only a compressed artefact crosses the boundary. Nuance that justified the conclusion is dropped, so the fast loop applies the conclusion in situations where it does not hold.
Fix: Include applicability conditions in the handoff, not just the conclusion. Make the fast loop check preconditions before acting on a slow-brain directive.
The routing decision is wrong in one of two directions: escalating too much, which destroys the cost argument, or too little, which starves the slow brain of exactly the hard cases it exists for.
Fix: Sample and shadow-run a fixed fraction of fast-brain-only traffic through the slow brain. Measure disagreement rate as the primary routing health metric.
The cheap model produces fluent, plausible output on inputs it does not actually understand. Fluency masks the failure, so no escalation signal ever fires.
Fix: Do not rely on self-reported confidence alone. Add stakes-based and novelty-based routing so escalation does not depend on the fast model recognising its own limits.
The two loops answer the same question differently, and the user sees both: a quick reply followed by a contradictory considered one. Trust degrades faster from visible self-contradiction than from a slow answer.
Fix: Decide up front whether the fast reply is provisional or final and signal it in the interface. Amend explicitly rather than silently contradicting.
Escalations arrive faster than the deliberative loop can clear them. The queue grows, handoffs get staler, and the architecture degrades into a fast-only system without anyone declaring it.
Fix: Bound the escalation queue explicitly, shed or defer with a visible policy, and alarm on queue depth and handoff age rather than on throughput alone.
When to Split, When Not To
A dual-process split adds a second loop, a router, a handoff format and a staleness problem. It pays for itself only when the cost or latency asymmetry is real and the traffic mix is skewed towards the routine.
| Condition | Signal | Verdict |
|---|---|---|
| Traffic is skewed | A large majority of events are routine and separable from the rest at low cost | Split |
| Latency budget is hard | A response or control action is required faster than deliberation can produce one | Split |
| Cost asymmetry is large | Frontier inference over full volume is an order of magnitude beyond budget | Split |
| Every event is high-stakes | Nothing in the stream can be safely handled without judgement | Do not split |
| Volume is low | Frontier inference over the whole stream is already affordable | Do not split |
| Routing is unlearnable | Difficulty is not predictable from the input before doing the work | Draft & verify instead |
Related: Steering for the handoff viewed as a control signal, since a slow brain conditioning a fast one is steering as the normal mode rather than an exceptional intervention, Agentic Loops for the iteration mechanics the slow brain usually runs inside, Judge & Escalation for the tiered-cascade version of the same economics, Agent Memory for the write-back path, Graph State Machine for expressing the two loops as explicit nodes, and LLM Performance for speculative decoding, which is the same draft-then-verify economics one level down, at the token.