tardie 0.3.0 → 0.4.0

package/README.md

@@ -15,14 +15,14 @@ A durable and modular agent harness built for self-improvement.
 ### A harness made for self-improvement
 As models get increasingly smart, they will be capable of writing their own harnesses to improve themselves ([Meta-Harness](https://arxiv.org/abs/2603.28052)). A harness that is too rigid and complex is a bottleneck to this. We need something more composable, and easy to author.
 
-We took inspiration from React. React derives the component tree as a function of state (`UI = f(state)`). Similarly, Tardigrade defines the harness as a set of state transitions derived from the event log, an idea with roots in [Harel's statecharts](https://www.sciencedirect.com/science/article/pii/0167642387900359).
+We took inspiration from React. React derives the component tree as a function of state (`UI = f(state)`). Tardigrade derives information and state transitions from the event log, an idea with roots in [Harel's statecharts](https://www.sciencedirect.com/science/article/pii/0167642387900359).
 
-$$\lbrace\mathrm{transitions}\rbrace = f(\mathrm{log})$$
+$$\lbrace\mathrm{information},\ \mathrm{transitions}\rbrace = f(\mathrm{log})$$
 
 ## Why Tardigrade
 
-- **Composable harness.** Add tools, code execution, budgets, compaction, and replies as independent capabilities.
-- **Strongly typed, built on Effect.** Typed services and Layers make each capability's dependencies explicit. A missing service fails during compile.
+- **Composable harness.** Add tools, code execution, budgets, compaction, and replies as independent components.
+- **Strongly typed, built on Effect.** Typed services and Layers make each component's dependencies explicit. A missing service fails during compile.
 - **Crash proof.** A durable host derives unfinished work from the stored log.
 - **Serverless.** All you need is a durable store, no process has to stay alive. Any new invocation reads the log, runs the transitions it owes, and settles.
 - **Inspect and improve every run.** Log as core supports native debugging, replay, and experiments with state forked from any checkpoint.
@@ -76,55 +76,64 @@ bun add tardie
 
 You can use `npm install tardie` instead. Install `tardie@next` to test a release candidate.
 
-### Create a capability
+### Create a component
 
-An agent is made of capabilities. A capability is one value with two halves: what the model is shown (`tools`, `system`), and how the calls that come back are handled (`serve`). This one gives the model a single tool:
+An agent is made of components. A component derives information and owed transitions from the log. Agent information includes system fragments, tool bindings, and context policy. This component gives the model one tool and owes no autonomous work:
 
 ```ts
-import type { Capability } from "tardie"
+import type { AgentComponent } from "tardie"
 
-const deploys: Capability = {
+const deploys: AgentComponent = {
   name: "deploys",
-  tools: () => [
-    {
-      name: "recent_deploys",
-      description: "List recent production deploys",
-      inputSchema: { type: "object", properties: {}, additionalProperties: false }
-    }
-  ],
-  serve: (call, log, answer) => {
-    if (call.name !== "recent_deploys") return undefined
-    return [answer([{ service: "api", revision: "a17c", summary: "Add rate limiting" }])]
-  }
+  derive: () => ({
+    info: {
+      system: ["Inspect recent deployments when a release may explain an incident."],
+      tools: [{
+        spec: {
+          name: "recent_deploys",
+          description: "List recent production deploys",
+          inputSchema: { type: "object", properties: {}, additionalProperties: false }
+        },
+        serve: (_call, _log, answer) => [
+          answer([{ service: "api", revision: "a17c", summary: "Add rate limiting" }])
+        ]
+      }],
+      context: []
+    },
+    transitions: []
+  })
 }
 ```
 
-`tools` derives what the model is offered from the log; a constant capability ignores it. `serve` handles a call that comes back: `answer` mints the transition that records the result, and returning `undefined` passes the call to the next capability. Replace the sample result with a call to your deployment API.
+`derive` is a pure log projection. Each tool binding keeps its specification and handler together, so a tool derived for the model is routable by construction. `answer` mints the transition that records the result. Replace the sample result with a call to your deployment API.
 
 The call follows one route:
 
-1. `tools` adds `recent_deploys` to the next model request.
+1. The component adds `recent_deploys` to its derived information.
 2. The model selects it and returns a tool call. Tardigrade records `ToolCalled` in the log.
-3. The shared router asks each mounted capability's `serve` to handle the call. `deploys` matches the name and answers.
+3. The shared runtime finds the paired handler in the information that offered the call and asks it to serve against the current log.
 4. Tardigrade records `ToolReturned`. The next model request includes the result.
 
 ### Compose an agent
 
-Mount the capability beside the built-in parts that this task needs:
+Mount the component beside the built-in parts that this task needs:
 
 ```ts
-import { agentOf, budget, codeMode, compaction, reply } from "tardie"
-
-const releaseAnalyst = agentOf([
-  deploys,     // recent_deploys and its handler
-  codeMode,    // durable JavaScript execution
-  budget,      // a per-turn code budget
-  compaction,  // bounded model context
-  reply        // results for parent agents
-])
+import { actorOf, agentRuntime, budget, codeMode, compaction, reply } from "tardie"
+
+const releaseAnalyst = actorOf(
+  agentRuntime(),
+  [
+    deploys,     // recent_deploys and its paired handler
+    codeMode,    // durable JavaScript execution
+    budget,      // a per-turn code budget
+    compaction,  // bounded model context
+    reply        // results for parent agents
+  ]
+)
 ```
 
-`agentOf` combines every model-facing part and runtime handler. The model sees `recent_deploys` and `execute` in one request. Policy capabilities react to the same log.
+`actorOf` combines the components under `agentRuntime`. The runtime interprets their information as inference and tool routing, while the core actor reconciles their transitions. The model sees `recent_deploys` and `execute` in one request. Policy components derive work from the same log.
 
 This agent can inspect deployments, analyze results with JavaScript, compact a long investigation, and report to a parent agent. Change the list to create another harness.
 
@@ -134,7 +143,7 @@ A run can follow this path:
 MessageReceived -> recent_deploys -> execute -> TurnCompleted
 ```
 
-Each action and result becomes an event that every capability can interpret.
+Each action and result becomes an event that every component can interpret.
 
 ### Run the composition
 
@@ -192,7 +201,7 @@ Effects have at-least-once execution. Each keyed result is recorded once. Provid
 
 ## Learn more
 
-- [Quickstart](docs/quickstart.md): build the event loop and its agent capabilities from first principles.
+- [Quickstart](docs/quickstart.md): build the event loop and its agent components from first principles.
 - [HTTP server](docs/how-to/server.md)
 - [CLI](docs/how-to/cli.md)
 - [Why Tardigrade](docs/explanations/why.md): learn what the log-as-state model makes possible.

package/examples/quickstart/actor.ts

@@ -1,5 +1,6 @@
 import {
-  agentOf,
+  actorOf,
+  agentRuntime,
   agentsPackage,
   budget,
   codeModeFor,
@@ -26,24 +27,30 @@ Return a concise answer with concrete findings.
 
 const instructions = {
   name: "instructions",
-  system: actorInstructions
+  derive: () => ({
+    info: { system: [actorInstructions], tools: [], context: [] },
+    transitions: []
+  })
 }
 
 export default defineActor({
   name: actorName,
-  // agentOf combines small capabilities into the actor's behavior.
-  actor: agentOf([
-    instructions,
-    // codeModeFor gives the model one code tool over the packages listed here.
-    codeModeFor({
-      // packages grant access to local files, HTTP, child agents, and saved tool results.
-      packages: [filesPackage(), fetchPackage(), agentsPackage(), workspacePackage()]
-    }),
-    // reply returns a finished turn to the actor that delegated it.
-    reply,
-    // budget stops work tools when the turn reaches its tool-call limit.
-    budget,
-    // compaction summarizes older context when a long turn outgrows its context window.
-    compaction
-  ])
+  // actorOf composes components under the explicit agent information runtime.
+  actor: actorOf(
+    agentRuntime(),
+    [
+      instructions,
+      // codeModeFor gives the model one code tool over the packages listed here.
+      codeModeFor({
+        // packages grant access to local files, HTTP, child agents, and saved tool results.
+        packages: [filesPackage(), fetchPackage(), agentsPackage(), workspacePackage()]
+      }),
+      // reply returns a finished turn to the actor that delegated it.
+      reply,
+      // budget stops work tools when the turn reaches its tool-call limit.
+      budget,
+      // compaction summarizes older context when a long turn outgrows its context window.
+      compaction
+    ]
+  )
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tardie",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "MIT",
   "author": "Clavia, Inc.",
   "description": "A durable agent harness. State is a pure function of the log.",

package/src/agent/{budget.ts → components/budget.ts}

@@ -1,8 +1,9 @@
 import { Clock, Effect } from "effect"
 import { transition, type Reactor } from "tardie/core/actor"
-import { budgetExhausted } from "./events"
+import { budgetExhausted } from "../events"
 import type { Event } from "tardie/core/event"
 import { turnHead, turnView } from "tardie/code/turns"
+import type { AgentComponent } from "../runtime/agent"
 
 // The budget reactor observes the turn's tool spend and fires BudgetExhausted once when it
 // passes the brief's budget. Detection lives here; enforcement lives with the tools reactor,
@@ -129,3 +130,17 @@ export const budgetReactorFor = (policy: Partial<BudgetPolicy> = {}): Reactor<ne
 
 // budgetReactor is that reactor on the default ceiling.
 export const budgetReactor: Reactor<never> = budgetReactorFor()
+
+// budgetFor derives budget transitions and contributes no agent information.
+export const budgetFor = (policy: Partial<BudgetPolicy>): AgentComponent => {
+  const reactor = budgetReactorFor(policy)
+  return {
+    name: "budget",
+    derive: (log) => ({
+      info: { system: [], tools: [], context: [] },
+      transitions: reactor(log)
+    })
+  }
+}
+
+export const budget: AgentComponent = budgetFor({})

package/src/agent/components/code.ts

@@ -0,0 +1,93 @@
+import { Clock, Effect } from "effect"
+import type { KeyValueStore } from "effect/unstable/persistence"
+import { transition, type Transition } from "tardie/core/actor"
+import type { Event } from "tardie/core/event"
+import { codeDispatched, codeKeys } from "tardie/code/events"
+import { codeReactorFor, type CodePolicy } from "tardie/code/execute"
+import type { Package, PackageRequirements } from "tardie/code/packages"
+import type { AgentComponent } from "../runtime/agent"
+import type { Answer, PendingCall } from "../runtime/tools"
+import type { ToolSpec } from "../request"
+
+const EXECUTE_TOOL: ToolSpec = {
+  name: "execute",
+  description:
+    "Run JavaScript against the connected packages. Packages are objects in scope; await their methods and end with `return <value>`. The returned value comes back as this call's result, and console output comes back beside it as `logs` (capped; return the value you need, print to inspect).",
+  inputSchema: {
+    type: "object",
+    properties: { code: { type: "string", description: "The JavaScript body to run." } },
+    required: ["code"],
+    additionalProperties: false
+  }
+}
+
+const CODE_SYSTEM_LEAD = "You act on the world by calling the execute tool with JavaScript; the packages in scope are:"
+export const CODE_SYSTEM = `${CODE_SYSTEM_LEAD}\nnone`
+
+// codeSystemFor names each package on its own line as name and description.
+export const codeSystemFor = (packages: ReadonlyArray<Package<unknown>>): string =>
+  `${CODE_SYSTEM_LEAD}\n${packages.length === 0 ? "none" : packages.map((p) => `${p.name}: ${p.description}`).join("\n")}`
+
+const settleFor = (
+  log: ReadonlyArray<Event>,
+  callId: string
+): { result?: unknown; error?: string; logs?: ReadonlyArray<string> } | undefined => {
+  const settle = log.find((e) => e.type === "CodeSettled" && String((e as { execId?: unknown }).execId) === callId) as
+    | { result?: unknown; error?: unknown; logs?: ReadonlyArray<string>; tmp?: unknown; size?: unknown; preview?: unknown; note?: unknown }
+    | undefined
+  if (settle === undefined) return undefined
+  const logs = settle.logs !== undefined && settle.logs.length > 0 ? { logs: settle.logs } : {}
+  if (settle.error !== undefined) return { error: String(settle.error), ...logs }
+  if (settle.tmp !== undefined) {
+    return { result: { tmp: settle.tmp, size: settle.size, preview: settle.preview, note: settle.note }, ...logs }
+  }
+  return { result: settle.result, ...logs }
+}
+
+const serveCode = (log: ReadonlyArray<Event>, call: PendingCall, answer: Answer): ReadonlyArray<Transition<never>> => {
+  const stamp = call.turn === undefined ? {} : { turn: call.turn }
+  if (log.some((e) => e.type === "CodeDispatched" && String((e as { execId?: unknown }).execId) === call.callId)) {
+    const outcome = settleFor(log, call.callId)
+    return outcome === undefined ? [] : [answer(outcome)]
+  }
+  const code = String((call.arguments as { code?: unknown } | undefined)?.code ?? "")
+  return [
+    transition({
+      key: `cd:${call.callId}`,
+      input: { execId: call.callId, code },
+      act: (input) =>
+        Effect.gen(function* () {
+          const at = yield* Clock.currentTimeMillis
+          return [codeDispatched({ execId: input.execId, code: input.code, ...stamp, at })]
+        })
+    })
+  ]
+}
+
+// codeModeFor derives the execute tool and code transitions from the same log and package scope.
+export const codeModeFor = <
+  const P extends ReadonlyArray<Package<never>> | ReadonlyArray<Package<unknown>> = readonly []
+>(
+  options: {
+    readonly policy?: Partial<CodePolicy>
+    readonly system?: string | ((log: ReadonlyArray<Event>) => string)
+    readonly packages?: P
+  } = {}
+): AgentComponent<KeyValueStore.KeyValueStore | PackageRequirements<P[number]>> => {
+  const packages = (options.packages ?? []) as unknown as P
+  const reactor = codeReactorFor(options.policy ?? {}, packages)
+  return {
+    name: "code",
+    keys: codeKeys,
+    derive: (log) => ({
+      info: {
+        system: [typeof options.system === "function" ? options.system(log) : options.system ?? codeSystemFor(packages as ReadonlyArray<Package<unknown>>)],
+        tools: [{ spec: EXECUTE_TOOL, serve: (call, current, answer) => serveCode(current, call, answer) }],
+        context: []
+      },
+      transitions: reactor(log)
+    })
+  }
+}
+
+export const codeMode: AgentComponent<KeyValueStore.KeyValueStore> = codeModeFor()

package/src/agent/{compaction.ts → components/compaction.ts}

@@ -1,9 +1,10 @@
 import { Clock, Effect } from "effect"
 import { transition, type Reactor } from "tardie/core/actor"
-import { compactionCompleted } from "./events"
+import { compactionCompleted } from "../events"
 import type { Event } from "tardie/core/event"
 import { turnOf, turnView } from "tardie/code/turns"
-import { Infer } from "./infer"
+import { Infer } from "../runtime/infer"
+import type { AgentComponent } from "../runtime/agent"
 
 // The compaction reactor: a pure observer of the context size, with the hysteresis design. A
 // guard fires compaction at a resolved tool round, any moment the open turn awaits no call, when
@@ -274,3 +275,17 @@ export const compactionReactorFor = (policy: Partial<ContextPolicy> = {}): React
 // compactionReactor is that reactor on the default policy. An agent on another policy builds its
 // own with `compactionReactorFor` and hands the same policy to its render.
 export const compactionReactor: Reactor<Infer> = compactionReactorFor()
+
+// compactionFor derives one context contribution and the transitions governed by that policy.
+export const compactionFor = (policy: Partial<ContextPolicy>): AgentComponent<Infer> => {
+  const reactor = compactionReactorFor(policy)
+  return {
+    name: "compaction",
+    derive: (log) => ({
+      info: { system: [], tools: [], context: [{ component: "compaction", policy }] },
+      transitions: reactor(log)
+    })
+  }
+}
+
+export const compaction: AgentComponent<Infer> = compactionFor({})

package/src/agent/{reply.ts → components/reply.ts}

@@ -1,10 +1,11 @@
 import { Clock, Effect } from "effect"
 import { Router } from "tardie/core/router"
 import { Self, transition, type Reactor } from "tardie/core/actor"
-import { replyDelivered } from "./events"
+import { replyDelivered } from "../events"
 import type { Event } from "tardie/core/event"
 import { replyEvent } from "tardie/core/message"
 import { turnTerminalOf, replyView } from "tardie/code/turns"
+import type { AgentComponent } from "../runtime/agent"
 
 // The reply reactor: report the turn's terminal home. When the inbound named a `replyTo`, the
 // terminal goes back to that actor as a plain `MessageReceived`, and the caller folds it as a
@@ -64,3 +65,12 @@ export const replyReactor: Reactor<Router | Self> = (log) => {
     })
   ]
 }
+
+// reply derives parent-delivery transitions and contributes no agent information.
+export const reply: AgentComponent<Router | Self> = {
+  name: "reply",
+  derive: (log) => ({
+    info: { system: [], tools: [], context: [] },
+    transitions: replyReactor(log)
+  })
+}

package/src/agent/components/tool-list.ts

@@ -0,0 +1,48 @@
+import { Clock, Effect } from "effect"
+import { transition } from "tardie/core/actor"
+import type { Event } from "tardie/core/event"
+import { toolReturned } from "../events"
+import type { ToolSpec } from "../request"
+import type { AgentComponent, AgentTool } from "../runtime/agent"
+
+// NativeTool is one named tool whose effect returns its model-visible result.
+export interface NativeTool<R = never> {
+  readonly spec: ToolSpec
+  readonly run: (input: unknown, context: { readonly callId: string; readonly turn?: string }) => Effect.Effect<unknown, never, R>
+}
+
+// toolList derives fixed tool bindings that pair every specification with its effect handler.
+export const toolList = <R = never>(
+  tools: ReadonlyArray<NativeTool<R>>,
+  system: string | ((log: ReadonlyArray<Event>) => string) = ""
+): AgentComponent<R> => ({
+  name: "tools",
+  derive: (log) => ({
+    info: {
+      system: [
+        (typeof system === "function" ? system(log) : system) ||
+          `You act on the world by calling the tools available to you: ${tools.map((tool) => tool.spec.name).join(", ")}.`
+      ],
+      tools: tools.map((tool): AgentTool<R> => ({
+        spec: tool.spec,
+        serve: (call) => {
+          const stamp = call.turn === undefined ? {} : { turn: call.turn }
+          return [
+            transition({
+              key: `tr:${call.callId}`,
+              input: { callId: call.callId, arguments: call.arguments, turn: call.turn },
+              act: (input) =>
+                Effect.gen(function* () {
+                  const result = yield* tool.run(input.arguments, { callId: input.callId, ...(input.turn === undefined ? {} : { turn: input.turn }) })
+                  const at = yield* Clock.currentTimeMillis
+                  return [toolReturned({ callId: input.callId, result, ...stamp, at })]
+                })
+            })
+          ]
+        }
+      })) as ReadonlyArray<AgentTool<unknown>>,
+      context: []
+    },
+    transitions: []
+  })
+})

package/src/agent/index.ts

@@ -7,13 +7,13 @@ export {
   type ActorDefinition
 } from "./artifact"
 
-// The parts a caller lists. An agent is capabilities over one log; the reactors underneath
-// remain reachable for a bespoke assembly.
-export { inferReactorFor, Infer, DEFAULT_INFER_POLICY, type InferPolicy, type InferRequest, type Render } from "./infer"
-export { budgetReactorFor, DEFAULT_BUDGET_POLICY, type BudgetPolicy } from "./budget"
-export { toolsReactorFrom, type Answer, type PendingCall, type Serve } from "./tools"
-export { replyReactor } from "./reply"
-export { compactionReactorFor, DEFAULT_CONTEXT_POLICY, type ContextPolicy } from "./compaction"
+// The parts a caller lists. An agent is components over one log; the reactors underneath remain
+// reachable for a bespoke assembly.
+export { inferReactorFor, Infer, DEFAULT_INFER_POLICY, type InferPolicy, type InferRequest, type Render } from "./runtime/infer"
+export { budgetReactorFor, DEFAULT_BUDGET_POLICY, type BudgetPolicy } from "./components/budget"
+export { toolsReactorFrom, type Answer, type PendingCall, type Serve } from "./runtime/tools"
+export { replyReactor } from "./components/reply"
+export { compactionReactorFor, DEFAULT_CONTEXT_POLICY, type ContextPolicy } from "./components/compaction"
 export { agentKeys } from "./events"
 export { resumeTurn, type ResumeTurnOptions, type TurnDriver } from "./resume"
 export {
@@ -63,6 +63,29 @@ export {
   type FetchPolicy
 } from "tardie/code/fetch"
 
-// The capability assembly: code mode is the default, and an agent measured against a fixed
-// tool list mounts its own (capability.ts).
-export { agentOf, renderOf, codeMode, codeModeFor, CODE_SYSTEM, codeSystemFor, toolList, reply, budget, budgetFor, compaction, compactionFor, type Capability, type NativeTool } from "./capability"
+// The component assembly: code mode is the default, and an agent measured against a fixed tool
+// list mounts its own (runtime/agent.ts).
+export {
+  AGENT_INFO_ALGEBRA,
+  agentRuntime,
+  renderOf,
+  type AgentComponent,
+  type AgentInfo,
+  type AgentTool,
+  type ContextFragment
+} from "./runtime/agent"
+export { codeMode, codeModeFor, CODE_SYSTEM, codeSystemFor } from "./components/code"
+export { toolList, type NativeTool } from "./components/tool-list"
+export { budget, budgetFor } from "./components/budget"
+export { compaction, compactionFor } from "./components/compaction"
+export { reply } from "./components/reply"
+export {
+  actorOf,
+  composeComponents,
+  reactorOf,
+  type Component,
+  type ComponentRequirements,
+  type ComponentRuntime,
+  type Derivation,
+  type InfoAlgebra
+} from "tardie/core/component"

package/src/agent/request.ts

@@ -1,7 +1,7 @@
 import type { Event } from "tardie/core/event"
-import { checkpointOf, contextPolicyOf, keepFromIndex, type ContextPolicy } from "./compaction"
+import { checkpointOf, contextPolicyOf, keepFromIndex, type ContextPolicy } from "./components/compaction"
 import { outputSchemaOf } from "./contract"
-import { budgetSpent, canRequestBudget } from "./budget"
+import { budgetSpent, canRequestBudget } from "./components/budget"
 
 // The model request, decided from the trajectory: system prompt, tool surface, message
 // projection. Domain policy lives with the agent; the platform maps these provider-agnostic

package/src/agent/runtime/agent.ts

@@ -0,0 +1,136 @@
+import type { Reactor, Transition } from "tardie/core/actor"
+import { composeComponents, type Component, type ComponentRuntime, type InfoAlgebra } from "tardie/core/component"
+import { messageKeys } from "tardie/core/message"
+import type { Event } from "tardie/core/event"
+import type { ToolSpec } from "../request"
+import { agentKeys } from "../events"
+import { inferReactorFor, type InferPolicy } from "./infer"
+import { toolsReactorFrom, type Answer, type PendingCall } from "./tools"
+import type { ContextPolicy } from "../components/compaction"
+import type { AgentR } from "../turn"
+
+// AgentTool pairs one model-visible tool specification with the handler for calls to that tool.
+// A derived tool is therefore advertised and routable from the same value.
+export interface AgentTool<R = never> {
+  readonly spec: ToolSpec
+  readonly serve: (
+    call: PendingCall,
+    log: ReadonlyArray<Event>,
+    answer: Answer
+  ) => ReadonlyArray<Transition<never, R>>
+}
+
+// ContextFragment names one component's context policy contribution. contextOf rejects
+// conflicting fields, so composition cannot hide a policy override.
+export interface ContextFragment {
+  readonly component: string
+  readonly policy: Partial<ContextPolicy>
+}
+
+// AgentInfo is the information an agent runtime interprets. Arrays retain component order and
+// postpone collision policy until the complete derivation is available.
+export interface AgentInfo {
+  readonly system: ReadonlyArray<string>
+  readonly tools: ReadonlyArray<AgentTool<unknown>>
+  readonly context: ReadonlyArray<ContextFragment>
+}
+
+// AgentComponent is a core component whose information is interpreted by the agent runtime.
+export type AgentComponent<R = never> = Component<AgentInfo, R>
+
+// AGENT_INFO_ALGEBRA preserves every information contribution in component order. renderOf
+// applies the agent-specific collision and rendering rules to the combined value.
+export const AGENT_INFO_ALGEBRA: InfoAlgebra<AgentInfo> = {
+  empty: { system: [], tools: [], context: [] },
+  combine: (left, right) => ({
+    system: [...left.system, ...right.system],
+    tools: [...left.tools, ...right.tools],
+    context: [...left.context, ...right.context]
+  })
+}
+
+const contextOf = (fragments: ReadonlyArray<ContextFragment>): Partial<ContextPolicy> => {
+  const context: Partial<Record<keyof ContextPolicy, number>> = {}
+  const owners = new Map<keyof ContextPolicy, string>()
+  for (const fragment of fragments) {
+    for (const [field, value] of Object.entries(fragment.policy) as Array<[keyof ContextPolicy, number]>) {
+      const prior = context[field]
+      if (prior !== undefined && prior !== value) {
+        throw new Error(`context field "${field}" declared by components ${owners.get(field)} and ${fragment.component}`)
+      }
+      context[field] = value
+      owners.set(field, fragment.component)
+    }
+  }
+  return context
+}
+
+const checkedTools = (tools: ReadonlyArray<AgentTool<unknown>>): ReadonlyArray<AgentTool<unknown>> => {
+  const names = new Set<string>()
+  for (const tool of tools) {
+    if (names.has(tool.spec.name)) throw new Error(`tool "${tool.spec.name}" declared more than once`)
+    names.add(tool.spec.name)
+  }
+  return tools
+}
+
+const infoFrom = <R>(components: ReadonlyArray<AgentComponent<R>>, log: ReadonlyArray<Event>): AgentInfo =>
+  composeComponents("agent.info", AGENT_INFO_ALGEBRA, components).derive(log).info
+
+// offerLogFor returns the prefix from which inference offered a pending call's tools. ModelCalled
+// is appended before inference, so the preceding prefix is exactly the log passed to render
+// (infer.ts, inferReactorFor; tla/Component.tla, OfferedIsRoutable). Calls created outside
+// inference have no mark and use the current log.
+const offerLogFor = (log: ReadonlyArray<Event>, call: PendingCall): ReadonlyArray<Event> => {
+  const called = log.findIndex(
+    (event) => event.type === "ToolCalled" && String((event as { callId?: unknown }).callId) === call.callId
+  )
+  if (called === -1) return log
+  for (let index = called - 1; index >= 0; index--) {
+    const event = log[index]!
+    if (event.type !== "ModelCalled") continue
+    const turn = (event as { turn?: unknown }).turn
+    if (call.turn === undefined || turn === undefined || String(turn) === call.turn) return log.slice(0, index)
+  }
+  return log
+}
+
+const renderInfo = (
+  info: AgentInfo
+): { readonly system: string; readonly tools: ReadonlyArray<ToolSpec>; readonly context: Partial<ContextPolicy> } => ({
+  system: info.system.filter((fragment) => fragment !== "").join("\n"),
+  tools: checkedTools(info.tools).map((tool) => tool.spec),
+  context: contextOf(info.context)
+})
+
+// renderOf derives the model request from the same component information that routing reads.
+export const renderOf = <R>(
+  components: ReadonlyArray<AgentComponent<R>>,
+  log: ReadonlyArray<Event>
+): { readonly system: string; readonly tools: ReadonlyArray<ToolSpec>; readonly context: Partial<ContextPolicy> } =>
+  renderInfo(infoFrom(components, log))
+
+// agentRuntime interprets AgentInfo as inference and tool-routing reactors. actorOf supplies the
+// composed information projection and adds each component's own transition projection.
+export const agentRuntime = (
+  policy: Partial<InferPolicy> = {}
+): ComponentRuntime<AgentInfo, AgentR> => ({
+  name: "agent",
+  algebra: AGENT_INFO_ALGEBRA,
+  keys: [messageKeys, agentKeys],
+  reactors: <C>(infoOf: (log: ReadonlyArray<Event>) => AgentInfo): ReadonlyArray<Reactor<AgentR | C>> => {
+    const toolsOf = (log: ReadonlyArray<Event>): ReadonlyArray<AgentTool<unknown>> => checkedTools(infoOf(log).tools)
+    const offeredTools = (log: ReadonlyArray<Event>, call: PendingCall): ReadonlyArray<AgentTool<unknown>> =>
+      toolsOf(offerLogFor(log, call))
+    const serve = (call: PendingCall, log: ReadonlyArray<Event>, answer: Answer) => {
+      const tool = offeredTools(log, call).find((candidate) => candidate.spec.name === call.name)
+      return tool?.serve(call, log, answer) as ReadonlyArray<Transition<never, AgentR | C>> | undefined
+    }
+
+    renderInfo(infoOf([]))
+    return [
+      inferReactorFor(policy, (log) => renderInfo(infoOf(log))) as Reactor<AgentR | C>,
+      toolsReactorFrom(serve, (log, call) => offeredTools(log, call).map((tool) => tool.spec))
+    ]
+  }
+})