Glossary

Alpha-scoped definitions. Concepts that arrive in later versions (evidence references, fork, lease tokens, side-effect keys, governed model slots, skill packs, plugins, the full capability firewall) are defined in those versions' glossaries.

A

Artifact — A stored payload (prompt, response, file, log, generated output, tool result) addressed by an artifact ID with a manifest and an on-disk blob. See Inspect Runs.

allVisits — An expression accessor ({{ steps.X.allVisits }}) that returns the ordered array of all committed visit outputs for a multi-visit step. Only valid on steps with maxVisits > 1. See LWIR Reference.

asHarnessWorkflow — Adapts a defineWorkflow definition into a Little Harness workflow, which becomes one typed tool when passed to createHarness({ workflows }). Requires definitionIdentity. This is the supported way to compose workflows; it replaces the Orchestrator. See Compose With Little Harness. (in-alpha)

AnimalDisambiguator — The deterministic suffix appended to a model slot id when two model() calls wrap the same underlying model name in the same workflow definition. The suffix (e.g., -tiger, -elephant) is chosen by hashing modelId + description against a fixed 64-entry animal list. See API Reference. (in-alpha)

B

Back-edge — A decision step's to target that names a step which has already executed in the current scope, creating an in-workflow loop. Valid only when the cycle contains a decision step and every step on the cycle has maxVisits ≥ 2. See LWIR Reference.

workflowHarness — The default Harness implementation shipped by the SDK. Uses an AI SDK agent loop, filesystem bash environment, scoped memory + scratch mounts, and skill injection. Substitutable with any object conforming to the Harness contract. See SDK Implementation Spec. (in-alpha)

Bash tool — The SDK-injected command interface available as ctx.bash inside harness sessions. Alpha implements it with just-bash, explicit Memory Store / Run Scratch / Skill mounts, persistent session env/cwd, and network off by default. It is event-logged as a harness tool call and is not a Tool Registry entry. See Harness. (in-alpha)

C

Capability — A reference to an executable side effect (tool, model call) that lives in the workflow definition's models or tools. The planner can reference capabilities the developer passed in; the runtime invokes them. Alpha uses a simple allowlist; the full firewall is planned post-alpha (see the Roadmap).

Capability drift — A RunFailedError { causeCode: "capability_drift" } raised when a tool's description, inputSchema, or outputSchema hashes differently from what the WorkflowVersion lock recorded. Alpha hashes all three fields. Also raised by manifest drift on harness session resume (see OrchestratorManifest, PlannerManifest, WorkerManifest). The failed run is preserved in Local World; re-run runWorkflow to produce a fresh WorkflowVersion against the updated snapshot.

D

Decision step — An LWIR step type (uses: "decision") that evaluates an ordered list of when expressions and routes execution to the first matching to target, or to default if none match. Its StepCompleted payload is { chosen: "<targetId>" }. Decision steps are excluded from fan-in output. See LWIR Reference.

Definition (WorkflowDefinition) — The ergonomic TypeScript authoring object passed to defineWorkflow(). Declarative and free of runtime infrastructure. See Workflow Config.

E

Event Log — The append-only record of facts and pointers for a run. Replay rebuilds state from the event log without re-calling external systems. Harness sessions write their own events (harness.session.*, harness.model.*, harness.tool_call.*) into the same log. See Inspect Runs.

F

Fixed plan — A plan written by hand and passed as defineWorkflow({ plan }) instead of drafted by a planner model. { steps } is completed from the definition (name, input and output schemas, permissions); a complete LWIR document is used as written. A fixed-plan workflow needs no model unless a step calls one. See Define a Workflow. (in-alpha)

Fixer — A harness role (kind: "fix_step") that self-recovers a failed code.run step. Spawned by the worker harness when a step declares onFailure.fixer. The fixer has bash + scratch + memory and iterates on the code body until the output validates against the step's schema or maxAttempts is exhausted. Fixes are run-scoped; persistent improvements go through memory and the next planner session. See LWIR Reference and SDK Implementation Spec. (in-alpha)

FixerManifest — The capability manifest for a fixer harness session. Extends WorkerManifest with fixerModelSlotId, fixerSystemHash, and fixerMaxAttempts. Includes the Bash sandbox capability hash. Stored in the session's harness.session.started event. Drift on resume fails closed. See SDK Implementation Spec. (in-alpha)

H

Harness — The agent runtime each role lives in: model + bash environment + scoped storage + tools + skills + agent loop + persistent conversation. In the spirit of Claude Code / OpenCode. The SDK ships a default (workflowHarness); devs substitute by conforming to the single-method contract run(task, ctx): Promise<HarnessResult>. Each session's model calls AND tool calls are event-logged for deterministic crash recovery. See SDK Implementation Spec. (in-alpha)

HarnessContext — The context passed to Harness.run(). Carries {model, system?, tools, memoryMounts, scratchMounts, mounts, bashCapabilities, durability, abortSignal, scope} plus optional Little Workflow compatibility conveniences such as bash and recorder. The SDK assembles ctx.tools by merging role-specific SDK-injected tools with the dev's extras before calling the harness. See SDK Implementation Spec. (in-alpha)

HarnessResult — The discriminated-union return type of Harness.run(). Variants: {kind: "plan"; lwir}, {kind: "orchestrate"; output}, {kind: "execute_step"; output; artifactRefs}, {kind: "fix_step"; output; fixedSource; attempts}. Also accepts {kind: "delegate_to_default"} to fall back to workflowHarness for a specific task kind. (in-alpha)

HarnessTask — The discriminated union passed as the first argument to Harness.run(). Variants: PlanTask, OrchestrateTask, ExecuteStepTask, FixStepTask, keyed by kind. See SDK Implementation Spec. (in-alpha)

L

lastOutput — An expression accessor ({{ steps.X.lastOutput }}) that returns the output of the most recent committed visit of a step. Equivalent to {{ steps.X.output }} for single-visit steps. Required (instead of .output) for steps with maxVisits > 1. See LWIR Reference.

LWIR — Little Workflow Intermediate Representation. The canonical JSON runtime format that Little Workflow executes. Hashable, canonicalizable, and immutable once registered. See LWIR Reference.

Local World — The zero-service local development backend. Uses SQLite/WAL event storage, artifact manifests/blobs, materialized replay, and local run locks under one data directory. See Local World.

M

max_visits_exceeded — A RunFailedCauseCode emitted when a step is about to start its maxVisits + 1-th execution. Carries failedStepPath. The failed run is preserved in Local World.

maxConcurrentSteps — A localWorld option that caps total in-flight step attempts across all parallel groups and serial steps in a run. Effective concurrency = min(group.maxConcurrency, world.maxConcurrentSteps - in-flight). Default undefined (no cap). Recommended for compute-heavy workflows.

maxVisits — An optional integer field on every LWIR step (range [1, 100], default 1). When greater than 1, the step may be revisited via a back-edge from a decision step. Multi-visit steps use visit-indexed paths (.visit[N]). See LWIR Reference.

Memory Store — A persistent, filesystem-shaped collection of text documents (markdown or plain text) mounted into a harness session's bash environment at /mnt/memory/{workflow,pipeline,org}/. Per Anthropic's Managed Agents memory model: agents read and write with normal file tools; self-improvement accumulates at the context layer across runs. Three default scopes: workflow (rw by that workflow's planners), pipeline (rw by the orchestrator), org (ro by all roles by default). Versioning, audit log, and content_sha256 preconditions are post-alpha. See SDK Implementation Spec. (in-alpha)

Model slot — A planner-visible, workflow-callable execution model option that LWIR steps reference by stable slot ID. Slot ids are auto-derived from the model name (e.g., gpt-4o-mini); collisions within a workflow get a deterministic animal suffix (see AnimalDisambiguator). The planner's own model is a separate slot not added to WorkflowDefinition.models. See API Reference.

O

OrchestrationRequest — The canonical, signed/versioned planner input. Declarative; contains the goal, capability metadata, model slots, and the requested output schema. When the outer loop is active, also carries outerLoop.cycleNumber, outerLoop.maxCycles, outerLoop.isFinalCycle, and outerLoop.priorCycles. See Core Mental Model.

Orchestrator (deprecated) — The conceptual role that operates over multiple WorkflowDefinitions together: chains outputs to inputs, spawns N parallel workflow runs from one input set, reorders, transforms data, and reduces results. Runs in a harness kind: "orchestrate" session. Tools include plan_workflow, run_workflow, and start_workflow. Configured on runOrchestration({ orchestrator }). Deprecated (LWF_DEP_ORCHESTRATOR) in favour of asHarnessWorkflow and scheduled to be unexported in the next minor.

OrchestratorManifest — The capability manifest for an orchestrator harness session. Contains harnessId, orchestratorModelSlotId, systemPromptHash, skillsHash, availableWorkflows (each with its WorkflowDefinitionHash), globalToolsHash, memoryStoreIds, bashCapabilitiesHash, and maxConcurrentSubRuns. Stored in the session's harness.session.started event. See SDK Implementation Spec. (in-alpha)

OuterLoopCycleCompleted — An event appended to the current cycle's event log after supervise() returns. Payload: { outerLoopId, cycleNumber, supervise: { kind, finalOutput?, promptNote? } }. Its presence makes outer-loop replay decidable without re-invoking supervise.

outer_loop_exhausted — A RunFailedCauseCode emitted when supervise returns { kind: "continue" } on the final cycle (cycleNumber === maxOuterCycles). The RunFailedError carries outerLoopId and lastCycleOutput.

Outer loop (planner-as-supervisor) — A feature where runWorkflow drives multiple compile-and-run cycles, calling PlannerConfig.supervise() after each cycle to decide whether to continue or declare done. Cycles share an outerLoopId. Bounded by maxOuterCycles. See SDK Implementation Spec.

P

pendingCycleRunId — A field on the outer-loop manifest (outer-loops/{outerLoopId}.json) written before a cycle begins and cleared after the cycle's OuterLoopCycleCompleted event is written. On resume after a mid-cycle crash, the outer-loop scheduler reuses this runId so Layer A replay can resume from the last committed step event.

Planner — The conceptual role that produces LWIR for one workflow from an OrchestrationRequest, and reviews that workflow's run output to decide whether to re-run with feedback (the outer-loop supervisor). Runs in a harness kind: "plan" session. Configured on WorkflowDefinition.planner as a PlannerConfig ({model, harness, system, skills?, tools?, supervise?}). See API Reference.

PlannerManifest — The capability manifest for a planner harness session. Contains harnessId, plannerModelSlotId, systemPromptHash, skillsHash, workflowDefinitionHash, globalToolsHash, memoryStoreIds, bashCapabilitiesHash, and optionally outerLoopContextHash for re-plans. Stored in the session's harness.session.started event. See SDK Implementation Spec. (in-alpha)

R

Replay — Reconstructs run state from the event log without calling models, tools, shell, code, or external APIs. At the harness level, model calls and tool calls are individually memoized; crashed harness sessions fast-forward by replaying committed harness.model.called, harness.model.responded and harness.tool_call.started, harness.tool_call.succeeded events. See Durability.

Retry — Re-executes a failed step using the same WorkflowVersion and input. Alpha retry is best used for idempotent steps; production-grade dedup arrives in v0.1.0. See Durability.

Run — One execution of a WorkflowVersion with one input packet. See Run A Workflow.

Run Scratch — Ephemeral, run-scoped filesystem storage that lets upper-layer agents pass curated context to lower-layer agents within one pipeline run. Mounted at /mnt/scratch/own/ (writable by the current role) plus read-only mounts /mnt/scratch/from-orchestrator/, /mnt/scratch/from-planner/, /mnt/scratch/peer-steps/. Distinct from Memory Store (which persists across runs). Cleaned up per retention policy. See SDK Implementation Spec. (in-alpha)

runWorkflow — runWorkflow(workflow, input, options?): the one-shot entry point that provisions a runtime, executes a single run (or outer-loop session when maxOuterCycles > 1), and returns the result. workflow.run(input, options?) is the same call. The deprecated orchestrator runs through runOrchestration instead. See Run A Workflow.

S

Sensitive step — A step with sensitive: true in its metadata. The field is parsed and validated by the LWIR validator in alpha but not yet honored by the runtime. Reserved so a future release can suppress inline output in the event log without a breaking LWIR upgrade.

Skill — A piece of procedurally-disclosed knowledge that teaches an agent how to handle a specific situation. Anthropic-aligned format: a directory containing SKILL.md with YAML frontmatter (name, description, optional model, allowed-tools) plus a markdown body. Single-file .md shorthand and explicit remote Git URL sources are also accepted. The harness auto-injects skill descriptions into the system prompt; bodies are read on demand via bash from .agents/skills/<name>/SKILL.md. Used by Planner, Orchestrator, AI Worker, and Fixer roles; not by code.run or tool.call (no model in the loop). Ships in alpha. (in-alpha)

StepAttempt — One attempt to execute a step within a run, including the fan-out item key when applicable.

Supervise decision — The return value of PlannerConfig.supervise(). Either { kind: "done", finalOutput } to terminate the outer loop, or { kind: "continue", promptNote? } to start the next cycle.

T

Tool — A capability declared with AI SDK's tool({description, inputSchema, execute}) and registered in the ToolRegistry under a name. The workflow declares the tools its plan may call in defineWorkflow({ tools }). The runtime invokes only tools recorded in the compiled WorkflowVersion. code.run steps invoke tools directly via the injected tools proxy without putting results through the model.

Tool registry — A process-local registry (createToolRegistry({...})) where the developer registers AI SDK tool() objects under a name. The WorkflowDefinition references tools by name; the compiler reads descriptors from the registry to build the WorkflowVersion lock; the runtime reads handlers at step lease. Mutable (new tools can be registered at any time) but immutable per-entry.

V

Visit-indexed step path — A step path with a .visit[N] suffix (0-indexed) used for steps with maxVisits > 1. Example: review-cands[cand_123].worker.visit[0]. Pure DAG steps (single-visit) retain their existing path format.

W

Worker — The conceptual role that executes one LWIR step. For AI steps (ai.generate), the worker makes one model call in a harness session, with no tools. For non-AI steps (code.run, tool.call, decision), execution is direct but mediated through the same harness for observability uniformity. Configured on WorkflowDefinition.worker; defaults to the SDK workflowHarness. (in-alpha)

WorkerManifest — The capability manifest for a worker harness session. Contains harnessId, workflowDefinitionHash, workflowVersionId, stepPath, stepConfigHash, modelSlotId (ai.generate only), skillsHash, allowedToolsHash, memoryStoreIds, and bashCapabilitiesHash. Stored in the session's harness.session.started event. See SDK Implementation Spec. (in-alpha)

WorkflowDefinitionHash — A hash of the workflow's identity-bearing authoring fields (planner config, models, tool allowlist, worker config, memory config, Bash sandbox config, schemas). Distinct from WorkflowVersion (which is a per-run LWIR hash). Stable across runs as long as the definition doesn't change. Used in orchestrator and planner manifests for drift detection. See SDK Implementation Spec. (in-alpha)

WorkflowVersion — A registered, immutable LWIR document plus capability snapshot and validation result. (A pre-run cost/risk estimate is part of the target design; nothing computes one in alpha. Cost is reported after a run — see Cost Report.) Identity = sha256(canonicalJson(LWIR)). Workers verify the snapshot before execution. Distinct from WorkflowDefinitionHash (definition-level identity). See Core Mental Model.