architecture

Node (Local Daemon)

What runs on your local PC: state, the agent, and the sync engine.

What Node is

Node is the local daemon. It runs as a long-lived process on a machine you control. Internally it has three responsibilities:

  1. State. It owns the current state of every active Thread, the cached project metadata, and a queue of pending intents.
  2. Agent execution. It hosts a Claude Code instance via the Anthropic Agent SDK. When an intent arrives, Node dispatches it to the agent.
  3. Sync. It talks directly to Git (or Perforce, depending on the project) to commit, push, pull, and resolve.

Why state lives here

Two reasons.

First, this is where the truth is. The files on disk are here. The agent’s working memory is here. Putting state anywhere else creates a synchronization problem we don’t need.

Second, this is where the work is. Compute, tooling, dependencies — they all live on this machine. Putting state somewhere else and compute here creates network round-trips for every state read.

Why the Agent SDK and not a custom integration

The Agent SDK gives us the Claude Code experience that developers already know — same tool surface, same MCP discovery, same skills. Building our own would mean reimplementing all of that and falling behind every time Anthropic shipped an improvement. Composing on top is the right strategy until and unless we have a specific reason to diverge.

Node’s outbound API

// illustrative — not the actual interface
class Node {
  // intent comes in
  async receive(intent: Intent): Promise<void>

  // state changes broadcast out
  on(event: 'state', cb: (s: State) => void): void
  on(event: 'token', cb: (t: TokenStream) => void): void
}

State changes go out as broadcasts to the relay; the relay fans out to subscribed clients. The wire format follows the Soulstream-compatible event vocabulary (thread_start, user_prompt_submit, pre_tool_use, post_tool_use, text_delta, thread_end, recap) — see tech_architecture.md §3 for the schema.

Recap on Thread end

When a Thread ends (Node observes the CC Stop hook and emits thread_end), Node generates a Recap — a short text summary of what happened — by calling a Manifoldone-managed LLM gateway. Only the summary text leaves the machine; raw tool inputs and outputs do not. The token cost is absorbed by Manifoldone (it’s not billed against the user’s own Claude account). The architecture rationale is in the tech reference.

What runs Node under the hood

In the early beta, Node is a Node.js 20+ process started by npx manifoldone dock. It uses TypeScript, the Anthropic Agent SDK, and a thin in-memory state store. Process supervision (PM2, launchd, systemd) is a Phase 2 concern — early beta runs in the foreground.

Naming note

Node was previously called “Pylon” in earlier drafts (a name inherited from the Estelle prior art). We renamed it for clarity: Node is what most distributed-systems readers expect, and it removes the RTS-game associations that were getting in the way for first-time readers. The technical model is unchanged.

Concurrency on a single Node is bounded by the MANIFOLDONE_MAX_CONCURRENT_THREADS env var (default 3). Raise it on bigger hardware; Phase 2 introduces a separate cap policy for Project-owned Nodes.