Separating Dialogue from Deliberation: Nora's Two-Process Architecture

A conversational agent that also performs long-horizon work must reconcile two regimes with incompatible time constants. Dialogue demands sub-second turn-taking and continuous responsiveness; goal pursuit unfolds over minutes, across many tool invocations, partial failures, and a changing environment. Nora — the agent inside Floodlight, our client over the Miriel context engine — must do both: hold a fluid spoken conversation while opening files, synthesizing and wiring interactive controls, driving terminals, and tracking multi-step objectives to completion.

We argue that reconciling these regimes is an architectural problem rather than a prompt-engineering one, and that the natural resolution is well-precedented in the literature. Nora is structured as a hybrid reactive–deliberative architecture: a reactive conversational process and a deliberative work process, decoupled through a shared blackboard, with a belief–desire–intention core, capability-scoped shared memory, and a mediated system-call boundary to effectors. The remainder of this article situates that design against the common alternatives, describes its components in the terms of the systems and agent-theory traditions they descend from, and reports the control-loop safeguards that make unbounded deliberation tractable.

The design space#

Most long-lived or multi-agent harnesses occupy one of three positions, each with a clear theoretical lineage and a characteristic failure mode.

The monolithic reasoning loop. A single model interleaves reasoning and action on one context — the think → act → observe pattern. Architecturally, this conflates dialogue control and task deliberation in one process. For a real-time conversational agent the consequence is direct: the model responsible for low-latency speech repeatedly suspends to deliberate, and its deliberative content intrudes on the dialogue. There is no structural boundary between talking and thinking, so there is no way to give them different clocks.

The flat multi-agent system. A coordinator decomposes a task and delegates to peer sub-agents — the contract-net tradition, and the shape of contemporary orchestration frameworks such as Hermes or OpenClaw. This is the appropriate instrument for parallel decomposition, but it addresses how to partition a task, not how to separate reaction from deliberation or where authoritative long-horizon state resides. Coordination becomes peer message-passing, and durable state tends to live wherever a coordinator's context happens to persist.

The plan-then-execute pipeline. A planner produces a plan; an executor realizes it. This is the classical sense–plan–act paradigm of early AI planning (in the STRIPS lineage), and it inherits that paradigm's well-documented fragility: the plan is an open-loop artifact committed before contact with the environment. Under nondeterminism — a resource not where it was assumed, an action that does not take on the first attempt, a user who revises the objective mid-task — the plan is stale and the executor is following a model of a world that no longer obtains. It was precisely this brittleness that motivated the reactive and hybrid architectures of the late 1980s.

Nora is a deliberate response to all three. It does not conflate the two regimes; it layers them. It is not a flat peer society; it imposes an asymmetric separation with a single owner of state. And it does not plan open-loop; it maintains a revisable set of goals with explicit success conditions, re-evaluated against perception on every cycle.

Two layers: a reactive Voice and a deliberative Supervisor#

The decomposition follows the hybrid, layered tradition in autonomous-agent design — the reactive/deliberative stratification of three-layer architectures (Firby's reactive action packages; Gat's account of three-layer organization) — in which a fast, tightly-coupled reactive layer is separated from a slower, model-based deliberative layer.

The Voice is the reactive layer: an OpenAI Realtime model whose sole responsibility is conversation — listening, speaking, turn-taking, and presenting Nora's persona. Its effector surface is intentionally minimal; it can register a user intent and handle speaker identification and authentication, and little else. It cannot open files, construct interface elements, or execute shell commands.

The Supervisor is the deliberative layer: a control loop running in its own process that, once per cycle (nominally every few seconds, but event-triggered, so a new intent wakes it immediately), performs a single model-deliberation step and emits one structured decision:

{
  "goals": [ {"op":"create","title":"…","done_when":"…"} | {"op":"complete","id":"…"} ],
  "tools": [ {"name":"open_surface","args":{…}} ],
  "say":   [ {"kind":"inform","text":"…"} ],
  "wait":  false
}

The decision names goal transitions, effector invocations, and utterances to be delegated back to the Voice for articulation.

The justification for placing the boundary precisely here is an impedance argument. The two layers have not only different time constants but different competencies. A real-time speech model excels at low-latency turn-taking and is mediocre at multi-step deliberation; a reasoning model exhibits the converse profile. Assigning either model the other's responsibility yields an agent that is simultaneously a poor interlocutor and a poor planner. Stratifying the responsibilities lets each operate in its competent regime: the Voice never blocks on work, and the Supervisor is never accountable for conversational latency. The user perceives a single agent; the system runs two processes.

Coordination: a blackboard realized as a cell#

The two layers do not invoke one another. They coordinate exclusively through a shared, structured medium — a blackboard in the sense established by the Hearsay-II speech-understanding system and later generalized by Nii: independent knowledge sources that communicate only by reading and writing a common repository, under opportunistic rather than hard-wired control. (The provenance is apt: the canonical blackboard system was itself built for speech.)

The blackboard is one instance of a general primitive we call a cell. A cell provides four facilities:

• a key–value store with last-writer semantics, for state;
• append-only streams read by cursor, so each consumer maintains an independent position and no entry is destructively consumed — Linda-style generative communication, in which producers and consumers are decoupled in both space and time;
• scoped keys, where each key carries an author-enforced {writers, readers} policy, so the substrate itself expresses who may write and read what — an access-control matrix realized as capabilities in the sense of Dennis and Van Horn;
• a membership set and an optional shared environment, since a cell is also a unit of workspace.

The system cell — the Voice/Supervisor blackboard — uses these facilities as a typed inter-process namespace:

This is the entire interface between dialogue and deliberation. The Voice deposits an intent and returns to conversing; the Supervisor consumes intents at its own cadence and deposits utterances the Voice later articulates. Because the streams are cursor-read and the keys are capability-scoped, the contract is expressed in the medium rather than in direct coupling between the processes. New participants — an observer publishing interface state, a sub-agent operating within a goal's workspace — attach to the blackboard without modification to either original process.

These are recognizably operating-system constructs: shared memory and typed channels under a protection policy. The system cell is the segment every process maps; subordinate work receives its own cells with their own environments, as a job receives its own working context.

The deliberative core as a belief–desire–intention loop#

The Supervisor's state and cycle correspond closely to the belief–desire–intention model of rational agency (Bratman; Rao and Georgeff). The world and observations keys constitute the agent's beliefs — its current model of the environment. The goals set constitutes its intentions: each goal is a record {id, title, done_when, status}, and done_when is a natural-language success condition — for example, "a 3D model file is open in the viewer," or "a control is bound to rotate the active model with a non-inverted vertical axis."

Each cycle the Supervisor re-derives action from the joint state of beliefs, intentions, and newly arrived intents. Nothing is precomputed. This is the decisive contrast with the plan-then-execute pipeline: there is no committed plan to be invalidated by a divergent environment, only an intention whose success condition is not yet satisfied and a fresh determination of the next action toward it. The loop is therefore closed — a feedback controller over perceived state — rather than open-loop. When perception is insufficient to evaluate a success condition, the Supervisor acquires evidence directly: it captures a screenshot, which is supplied as a visual input on the subsequent cycle, completing the perceive–decide–act loop across the process boundary.

Intentions are durable. Because they reside in the cell, which is persistent, work outlives any particular stretch of conversation: a user may fall silent for the duration of a network scan while the Supervisor retains full knowledge of its objectives and their rationale. This is the property that flat multi-agent and monolithic designs most often fail to provide — long-horizon state with a definite owner and a definite home, rather than state diffused across a context window or a dialogue history subject to summarization.

Bounded deliberation: liveness and termination#

A controller that re-derives action from perception every few seconds is expressive and, without constraint, non-terminating. The substantive engineering in the Supervisor lies less in the deliberation step than in the governor surrounding it, and each safeguard corresponds to a classical liveness or saturation concern. We report them with the observed failure that motivated each, since the failures are the evidence.

Progress versus divergence. An early unbounded version, directed to construct a single control, produced it, could not perceive that it had succeeded, and reconstructed it repeatedly — a divergent loop. The remedy is a per-intention deliberation budget: absent a new user intent, a goal may be self-driven for only a bounded number of cycles before the Supervisor suspends it and refers the decision to the user. A deliberative loop lacking a termination criterion will pursue an unsatisfiable goal indefinitely; the budget supplies that criterion.

Stagnation. Distinct from divergence is repetition — the model proposing an identical action across successive cycles. A repetition guard detects an unchanged action and suspends rather than re-issuing it, encoding out the "retry the failing action unchanged" pathology.

Blocked versus spinning. A subtler error conflated waiting with stalling: a network scan legitimately occupies minutes, hence many cycles, and the deliberation budget initially charged each one — so the Supervisor declared itself stalled during a functioning operation and began issuing redundant input. The correction distinguishes the two conditions using a signal derived from the live terminal state — whether the shell is at a prompt — and treats an in-progress command as legitimate blocking: the deliberation budget is not charged, no further effector calls are issued, and the loop simply waits, under a separate and larger bound so that a genuinely hung command still eventually surfaces to the user. The distinction between blocked-on-I/O and busy-waiting is a scheduler's, and it is exactly the distinction required here.

These mechanisms are the control-theoretic counterparts of watchdog timers, saturation limits, and anti-windup: bounds that keep a closed loop stable and progressing. The deliberation model is the processing element; the governor is the scheduler that determines when a task has exhausted its allowance, when it is blocked, and when it is genuinely advancing.

Effectors across a protection boundary#

A final boundary completes the operating-system correspondence. The Supervisor executes in its own locus of control, whereas its effectors — opening files, constructing interface surfaces, driving the viewer, reading a terminal, capturing a screenshot — execute elsewhere, on one or more execution surfaces. These surfaces need not coincide: the surface that renders the interface and answers perceptual queries is not necessarily the surface that owns a given filesystem or shell, and a single goal may touch several at once — a screenshot answered by one, a directory read by another. What the surfaces share is not a location but a protocol. The Supervisor therefore cannot invoke any effector directly. It issues a remote effector call: a request naming the effector is placed on the event bus, routed to the surface that owns it, executed there through the same dispatch path used by the Voice's own effector calls, and its result returned to satisfy a pending promise in the calling process.

This is a system call. The deliberative kernel cannot manipulate a device directly; it traps across a protection boundary to the surface that owns the effector — the driver layer — and receives a result, irrespective of where that surface physically resides. There is a single mediated protocol for effects, addressable from either layer — the Voice via its data channel, the Supervisor via remote call — and the drivers are indifferent to the caller. One mediated effector protocol, rather than per-surface ad-hoc access, is what makes the system's effects analyzable at all; and because authority is expressed by capability-scoped keys in the shared medium, it is the medium, not bespoke checks at each surface, that enforces who may do what.

A corollary of reifying all coordination state — intents, beliefs, intentions, the Supervisor's per-cycle decisions, the Voice's effector calls and response timing — in the cell or an associated trace is that the entire two-process system is observable as a state dump. Diagnosing a distributed agent is ordinarily an exercise in reconstruction; here it reduces to reading serialized state, and the safeguards above were in fact derived from such dumps.

A representative episode#

The mechanisms are easier to see cooperating than enumerated. Consider a representative episode — illustrative rather than logged, though every step is within the system as described. A user asks Nora to open a camera inventory and report which devices on the network are reachable. The Voice acknowledges and records the request as an intent within the same conversational turn; the Supervisor adopts an intention whose success condition is "each inventoried camera is annotated reachable or unreachable." No existing effector answers reachability, so the Supervisor does not refuse the task or improvise around it: the effector set is generative, not fixed, and it constructs the missing capability — a status probe defined at runtime and thereafter callable by name, exactly as a new interface surface is built when no typed widget will do. It then invokes the probe it has just authored.

The probe occupies the better part of a minute. Two things happen in that interval that a single-threaded agent forfeits. First, the user asks, unprompted, for a particular camera's model number, and is answered at once: the dialogue runs on its own clock, and the Supervisor's wait does not detain it. Second, the governor, observing a command in progress rather than a repeated action, classifies the interval as blocking rather than spinning, declines to charge the per-intention deliberation budget, and simply waits — so the long-running operation is not mistaken for a stall and interrupted. When the probe returns, the user asks for the result "on a board"; the Supervisor builds an interface surface bound to the cell key the probe writes, and when the user adds "make the offline ones red, not just grey," it edits that surface in place rather than constructing a second one — the correction changes one rule in an existing artifact, not its identity.

The user then takes a phone call and is silent for several minutes. On returning — "which ones were offline again?" — the answer is immediate and intact, because the intention and its accumulated findings reside in the cell and never depended on the conversation's continuity; nothing was diffused across a dialogue history that summarization might have eroded. Had one camera's probe hung instead of completing, the outcome would differ in exactly one respect: the deliberation budget for that intention would expire and the Supervisor would surface the stuck device to the user rather than retrying it indefinitely. Each property the architecture claims — a responsive dialogue, a generative effector set, editing in place, the discrimination of blocking from spinning, and durable owned intentions — is load-bearing once in this single arc, which is the architecture in motion rather than at rest.

Discussion#

Evaluated against the three archetypes, the decomposition's advantage is that their characteristic pathologies are structurally absent rather than merely mitigated. The conversation cannot be blocked by the work, because dialogue and deliberation run on separate clocks joined only by streams. The work does not depend on the conversation's continuity, because intentions are durable, owned, and homed in a cell. No plan can become stale, because there is no plan — only success conditions re-evaluated against current perception. And the system extends without renegotiating its core, because coordination is a typed, capability-scoped blackboard to which new observers, sub-agents, and effectors attach.

None of these constructs is novel in isolation. The contribution is their composition: a reactive layer and a deliberative layer in the hybrid-architecture tradition; a blackboard in the Hearsay-II tradition, generalized to a tuple-space-like coordination primitive; a belief–desire–intention deliberative core closing a perception loop where classical planning left it open; capability-scoped shared memory; and a mediated system-call boundary to effectors — assembled into a single agent that sustains a real-time conversation while pursuing goals across minutes and tools.

That the resulting structure recapitulates the abstractions of an operating system — processes communicating through shared memory and typed channels, capabilities, system calls, and a scheduler whose central task is to distinguish progress from divergence and blocking from spinning — is not metaphor. It is the same set of problems recurring, and the same decomposition resolving them. The reactive layer conducts the dialogue; the deliberative layer conducts the work; they meet only at a blackboard. That separation is Nora's architecture.