The words the Seed Agents pages use, one line each, linked to the page that defines the term. The three nouns and the verbs come first, because every other term builds on them. Protocol terms such as account, capability, and comment are in the site-wide glossary.

The three nouns

Space: everything an agent has, as one addressable tree: ~/memory/, ~/tools/, ~/triggers/, and ~/self.

Log: everything that happened in a thread, an append-only sequence of events each stamped with an actor.

Runs: everything that executes, one durable row per turn, child, and script, in a tree that doubles as the dispatch queue.

The verbs

read: one verb for every address, from memory files to hm:// documents, web pages, the activity feed, and other threads.

write: the mirror of read: memory, authored tools, triggers, IPFS uploads, and signed Hypermedia publishing under the publish grant.

call: invoke a callable tool by name; a wrong or missing input answers with the tool's contract.

delegate: spawn a child run, either a model child given a brief or a script child given source.

plan: maintain the thread's visible checklist.

status: set the session's title and live description as they appear in session lists; see tools.

continuesession: carry the conversation into a fresh successor session; see session continuation.

Tools

tool document: every tool is a content-addressed DAG-CBOR document whose CID is its version: a builtin binding, an authored lambda, or an MCP projection.

contract: a tool's full model-facing spec, description plus input and output schemas, returned by read ~/tools/<name>.

Space index: the compact <space> block in every system prompt, one line per tool plus the memory top level and active triggers.

promotion: once a tool's contract has entered the transcript, the tool becomes a provider tool for the rest of the thread.

grants: the per-agent permissions: the callable set, the publish grant, and the enabled MCP servers; the verbs are never grants.

MCP server: a remote Model Context Protocol server connected per account and enabled per agent, whose tools appear as <server>__<tool> documents.

touch-expand: what call does on a miss. The tool's contract comes back in place of an error, so the retry succeeds. Defined on tools.

callable: a tool dispatched through call, as opposed to a tool handed to the model directly: search, query, attributes, web_search, navigate, execute, an authored lambda, or an MCP tool; see tools.

Delegation and orchestration

child: a run spawned by delegate; a model child gets its own session, a script child runs in the QuickJS engine.

brief: the markdown task briefing that becomes a model child's first message word for word.

typed result: a child spawned with an output schema must deliver its result through the return_result tool.

script and ctx: a script child's world: ctx.call, ctx.delegate, ctx.parallel, ctx.step, ctx.plan, ctx.sleep, ctx.waitForEvent, ctx.continueAsNew.

journal: a script run's durable effect record; resume replays the source against it and completed effects never re-execute.

journal entry: one record in a journal, a JSON value with a kind (call, result, timer, fired, wait, event, now, log, step, plan), the callSeq of the ctx call it belongs to, and a content key replay matches on.

run tree: a root run and every run spawned under it, all sharing one rootRunId; what ListRuns {rootRunId} returns and a runs/<rootRunId> subscription replays.

root run: the run a message or a firing started, at depth 0; its children carry parentRunId and a greater depth.

turn: one model run of a session, from a message or a wake to the reply; each turn is a run row of kind agent.

park and wait: a run pausing without holding resources, for children, a timer, an event, or a budget pause.

wake source: whatever ends a park: children finishing, a timer, a signal, an activity event, or a person resuming.

continueAsNew: a long-running script finishing into a fresh successor run with a clean journal.

thoroughness: the quick, normal, or deep preset that sets a run tree's depth and fan-out budget; see tools and the delegation budgets proposal.

obligation: what a run owes when it ends, an undelivered typed result or unfinished plan steps, reported as unmetObligations and never silently written off; see persistence.

Plans

step: one checklist item with a stable id and a human label.

attachment: a child spawned while a step is running belongs to that step.

batch step: one running step owning a whole parallel batch of children.

The symmetric log

actor: who did it: user, agent, system, or trigger; every event has one, stamped or derived from its shape.

thread: a synonym these pages use for a session, the conversation a log records.

wrench palette: the tool button in the composer that lets a person run read, write, and call themselves, with results landing on the log as user events.

session continuation: carrying a conversation into a fresh successor session with a structured handoff. The old history is not compacted.

Triggers

trigger: standing configuration binding a source (comment, mention, reply, document-author comment, site update, a list of those as conditions, schedule, webhook, run completed) to a continuation.

firing: one trigger activation, deduplicated exactly once, with run-completed chains loop-guarded at eight hops.

continuation: what a firing does: start a new thread, wake a parked run, or run a tool or script with no model; see triggers. Not to be confused with session continuation, which carries a conversation into a successor session.

condition: one alternative inside an activity trigger, {id, source}; the trigger fires once when any condition matches, and the firing records matchedConditions; see triggers.

claim: the trigger_event_claims row inserted for (account, trigger, firing key) before an activity firing is created, the admission authority that makes a firing exactly-once; see triggers.

firing key: the key a feed event dedupes on, blob-<cid> of the comment version, which a comment and its citation twin share (activityFiringKey); the raw event key (activityEventKey) differs per sibling.

activity monitor: the server's poll loop over the Hypermedia activity feed that matches events against triggers and waiting runs; see triggers.

Control plane

signed envelope: the DAG-CBOR wrapper around every action, signed by the account key or a delegated key; see the signed API.

signing identity: the agent's own Ed25519 account key, created on the agents server and given a capability by the owner's account, which the agent signs its Hypermedia writes with; see tools and security.

subscription: a signed Subscribe action over the WebSocket that streams account, agent, session, or run changes; see WebSocket subscriptions.

collaborator: a Seed account invited to an agent as reader or writer; publicRead and publicChat open an agent to any signed account; see the signed API.