The Interpreter-Shaped Harness

How to read this plate

Each block is one subsystem of Prime Agent. Its height is a rough proxy for code mass, calibrated the same way across every harness so the plates are comparable. Hatching and tint group blocks into districts — surfaces, the turn, tools, context, the model layer, safety, extensibility and state.

Lines trace the real data flow of a single turn plus the major supporting links. Pick any block for a plain description and the files it was read from, or trace the turn to walk the path a request actually takes.

Prime Agent · Block A · Surfaces & entry

CLI ENTRY

Parses the command line, then either attaches to a running agent or starts a new one.

src/cli.ts (15 L) → cli-main.ts (46 L) → main.ts (1,704 L); packages/coding-agent

Prime Agent · Block B · Surfaces & entry

DAEMON SUPERVISOR

A background service that owns every running agent, routes messages between them and restarts the ones that die.

src/modes/daemon/daemon-mode.ts (7,095 L) + daemon-supervisor.ts (5,239 L) + daemon-supervisor-ownership.ts (924 L); 24,077 L of daemon code in total

Prime Agent · Block C · Surfaces & entry

AGENT CONNECTION

The boundary between the terminal you see and the agent doing the work, so closing the terminal does not stop the run.

src/modes/agent-connection/daemon-agent-connection.ts (2,113 L); wire format in modes/daemon/daemon-protocol.ts (1,187 L)

Prime Agent · Block D · Surfaces & entry

INTERACTIVE TUI

The full-screen terminal interface, inherited from pi and then grown considerably.

src/modes/interactive/interactive-mode.ts (9,903 L); packages/tui/src (14,635 L)

Prime Agent · Block E · Surfaces & entry

HEADLESS MODES

Non-interactive front doors for scripts, editors and other programs.

src/modes/{rpc,acp}/, print-mode.ts, headless-completion.ts; docs/json.md, rpc.md, acp.md

Prime Agent · Block F · Surfaces & entry

AGENTS VIEW

A browser over every running, idle and saved session, since many agents run at once.

src/modes/agents-view/agents-view-mode.ts (2,916 L) + agents-view-state.ts (999 L)

Prime Agent · Block G · The turn

AGENT SESSION

The orchestrator: it owns the queue, the model calls, the tool dispatch, compaction, goals and every child agent.

src/core/agent-session.ts (10,946 L) — 7.2% of source in one file, against pi's 3,344 L; + agent-session-runtime.ts, -services.ts, -config.ts

Prime Agent · Block H · The turn

AGENT LOOP

Drives one turn: assemble the prompt, stream the model, run what it asked for, decide whether to continue.

packages/agent/src/agent-loop.ts (963 L) agentLoop / agentLoopContinue / runAgentLoop — a fork of pi's 796-line loop

Prime Agent · Block I · The turn

SCHEDULER

Re-enters a session without a person present, on a timer, a schedule or a standing goal.

src/core/cron-jobs.ts (1,735 L), autonomous.ts (593 L), goals.ts (290 L); skills/rlm-heartbeat

Prime Agent · Block J · Tools

IPYTHON TOOL

The only tool the model is given. Everything it does, it does by writing Python.

src/core/tools/ipython.ts (707 L); src/core/tools/index.ts declares `type ToolName = "ipython"` and createAllToolDefinitions() returns exactly that one entry

Prime Agent · Block K · Tools

KERNEL MANAGER

Keeps a real Python process alive across the whole session, so variables and imports survive between turns.

src/core/kernel/index.ts (1,597 L) KernelManager; bootstrap.ts (929 L); fork-server.ts (363 L) exists purely to make kernel start-up fast

Prime Agent · Block L · Tools

HOST REQUESTS

A typed channel letting the model's Python ask the agent to do things only the host can do.

src/core/kernel/index.ts HOST_COMM_TARGET = "host.request", createHostRequestHandler; custom display MIME types for diffs, attachments and agent messages

Prime Agent · Block M · Tools

EDIT + BASH OPS

File editing and shell access still exist, but as host operations and a bundled skill rather than tools the model calls.

src/core/tools/edit.ts (533 L), bash.ts (452 L) — exported for embedders via core/sdk.ts (386 L) and reachable as `ReplayBuiltInToolName = "bash" | "edit"` (extensions/types.ts:405) so old transcripts still render; skills/edit

Prime Agent · Block N · Context & memory

SYSTEM PROMPT

An immutable base prompt describing the recursive-interpreter model of work.

src/core/system-prompt.ts (184 L) + core/prompts/rlm.ts (222 L)

Prime Agent · Block O · Context & memory

CONTINUAL HARNESS

Lets the agent write durable lessons about how to work — extra prompts, memories, skill notes — with history and rollback, without ever touching the base prompt.

src/core/refinement/refinement.ts (1,017 L): HarnessState, loadHarnessState, mergeHarnessStates, global and per-session state dirs; exposed as the `refine` skill

Prime Agent · Block P · Context & memory

COMPACTION

Summarises the transcript when it grows too long, so a run can continue past the context window.

src/core/compaction/compaction.ts (788 L) + branch-summarization.ts (307 L) + utils.ts (149 L); src/core/context-tree.ts (319 L)

Prime Agent · Block Q · Context & memory

SKILLS

Reusable capabilities that are importable Python packages, so extending the agent happens inside the interpreter.

src/core/skills.ts (623 L); 13 bundled skills incl. refine, edit, compact, goal, agent-message, skill-creator, websearch

Prime Agent · Block R · Context & memory

RESOURCE LOADER

Gathers the instruction files, memories and skill descriptions that get assembled into a turn.

src/core/resource-loader.ts (938 L)

Prime Agent · Block S · Model layer

PROVIDER LAYER

One streaming interface over every model vendor the agent can talk to.

packages/ai/src (13,441 L excl. the generated catalogue); 9 wire APIs registered in providers/register-builtins.ts

Prime Agent · Block T · Model layer

MODEL REGISTRY

Resolves a model name to a provider, its limits and its pricing.

src/core/model-registry.ts (1,597 L) + model-resolver.ts; 32 providers and 1,227 models in packages/ai/src/models.generated.ts

Prime Agent · Block U · Model layer

AUTH STORAGE

Holds the credentials for each provider and refreshes them mid-session.

src/core/auth-storage.ts (1,126 L) + prime-inference-auth.ts (736 L)

Prime Agent · Block V · Safety

NO OS SANDBOX

There is no operating-system boundary. Model-written Python runs with your permissions, and the docs say so plainly.

No sandbox-exec, bubblewrap, Landlock, seccomp or restricted-token path in source; docs/architecture.md states workers and kernels are "not security sandboxes"; @anthropic-ai/sandbox-runtime is a devDependency and sandboxing ships as examples/extensions/sandbox

Prime Agent · Block W · Safety

ADMISSION GUARDS

The few limits that do exist: what may enter a prompt, what may leave a tool, and how deep recursion may go.

src/core/prompt-admission.ts (42 L), output-guard.ts (74 L), rlm-max-depth.ts (13 L)

Prime Agent · Block X · Extensibility

EXTENSION RUNNER

Loads third-party extensions and runs them against the session's lifecycle events.

src/core/extensions/runner.ts (1,062 L), types.ts (1,398 L), loader.ts (593 L); 72 worked examples under examples/extensions/, inherited from pi

Prime Agent · Block Y · Extensibility

PACKAGE MANAGER

Installs and updates extensions and skills from inside the agent.

src/core/package-manager.ts (2,444 L) + src/package-manager-cli.ts (1,641 L)

Prime Agent · Block Z · Extensibility

MCP CLIENT

Connects to Model Context Protocol servers to borrow their tools.

src/core/mcp/mcp-manager.ts (205 L); docs/mcp-integrations.md

Prime Agent · Block AA · State

SESSION JSONL

Every session is one append-only JSONL file plus a folder of artifacts, which is what makes resuming and forking possible.

src/core/session-manager.ts (2,090 L) writes <sessionId>.jsonl + a per-session artifact dir; session-action-store.ts (435 L), session-lease.ts

Prime Agent · Block AB · State

SETTINGS

Layered configuration with migrations, shared by the daemon and every session it owns.

src/core/settings-manager.ts (1,263 L) + migrations.ts

Prime Agent · Block AC · State

TRACES

Records what happened in a run for later inspection and export.

src/core/agent-traces.ts (968 L) + telemetry.ts; src/core/export-html/