Agents

std-agent-completion

takes a prompt, returns generated text.

Entity: Completion (runtime)

Traits

std-agent-context

keeps what an in-app assistant sends the model bounded. COMPACT { messages } passes a conversation of at most keepMessages turns straight through as COMPACTED; a longer one has its older turns summarized with call-service llm summarize into one leading note and keeps the last keepMessages turns verbatim. If summarizing fails, the older turns are dropped and the recent ones still go through, with a visible warning — a summarizer outage never blocks the assistant. Headless. Nothing is persisted: the conversation itself lives in std-agent-session.

Entity: AgentContextWindow (runtime)

Traits

Config knobs

std-agent-fix-loop

validate an orbital, generate a repair prompt if errors, apply fix.

Entity: FixLoop (runtime)

Traits

std-agent-memory

what an in-app assistant remembers across conversations. Owns AgentMemory rows (content + its embedding, ownerId = the real @user). RECALL { messages } embeds the last turn with call-service llm embed, ranks the stored memories whose embedding is comparable (same length as the query's) by cosine similarity and emits RECALLED { messages, context } with the closest recallLimit memories joined into one context string (empty when nothing is stored); if embedding fails it emits RECALLED with an empty context, so a memory outage never blocks the assistant. REMEMBER { reply } stores the exchange it just recalled for (asked + answered) with its embedding. AgentMemoryRecall is headless (failures show as toasts); AgentMemoryBrowse is the list view. Rows are meant to be private to their owner: the binding organism declares the @read scoping.

Entity: AgentMemory (persistent)

Traits

Config knobs

std-agent-planner

recall memories, then generate a plan from the prompt + recalled context.

Entity: PlannerPlan (runtime)

Traits

std-agent-session

the conversation with an in-app assistant. AgentThread owns the persisted AgentMessage rows (role, content, ownerId stamped with the real @user, createdAt): SEND stores the user's message, reloads the thread and emits CONVERSE with the whole conversation, oldest first, for std-agent-tool-loop to answer; REPLIED stores the reply. AgentConversation is what the user sees, in the browser: the thread as chat bubbles with every step the assistant takes interleaved live (STEP: each model call, each tool it used and what the app answered), a thinking row while it works, and a chat bar. The two talk over the assistant contract, from any orbital: AgentConversation emits ASSISTANT_SEND and hears AgentMessagesLoaded, ASSISTANT_THREAD_FAILED, ASSISTANT_STEP, ASSISTANT_REPLIED and ASSISTANT_REPLY_FAILED; AgentThread hears ASSISTANT_SEND. So a conversation placed on any section's page reaches the app's one assistant (std-agent-assistant) with no wiring. Rows are meant to be private to their owner: owner-scoped access needs an [identity] roster, so the binding organism declares the @read/@create scoping on AgentMessage — this generic atom cannot.

Entity: AgentMessage (persistent)

Traits

Config knobs

std-agent-tool-call

takes messages + tools, returns tool-call result.

Entity: ToolCall (runtime)

Traits

std-agent-tool-loop

answers a conversation by operating the running app as the caller, through call-service llm call-tools. Its tools are { scope: declared } (every declared external input plus a read over every persisted entity), or named declared inputs (addressed like a listens source: Trait.EVENT, Orbital.Trait.EVENT) and entities to read; each input fires as the signed-in user through the ordinary dispatch (guards and entity policies apply) and each read returns only the rows the caller may read. Headless: the conversation UI (std-agent-session) shows the reply; a failure shows as a toast. CONVERSE carries the conversation (and optionally what std-agent-memory recalled); ASSISTANT_STEP carries each step live while it works (a model call, a tool it used, what the app answered) to the asking tab; ASSISTANT_REPLIED carries the reply, every step and the token usage; ASSISTANT_REPLY_FAILED carries the error. These names are the assistant contract std-agent-session's conversation hears from any orbital. Compose with std-agent-session (the conversation) and std-agent-trace (the step record).

Entity: AgentTurn (runtime)

Traits

Config knobs

std-agent-trace

the persisted record of what an in-app assistant did. Each REPLIED (from std-agent-tool-loop) stores one AgentRun row: the reply, every step (each model call, each tool used with its arguments, whether it took effect and why not), the tokens and the model calls; each REPLY_FAILED stores a failed run with its error. The record verification grades and later optimisation reads, in one format for tests and production. AgentTraceRecorder is headless; AgentRunBrowse is the run list. Rows carry ownerId (the real @user); the binding organism scopes @read.

Entity: AgentRun (persistent)

Traits

std-agent-assistant

an in-app assistant that operates the running app for the signed-in user. Each section's floating button opens it in a side panel docked beside the page (std-panel-launcher; a side sheet on small screens), where the conversation shows every step the assistant takes live as it works; /assistant is the same conversation as a full page, in the app's own shell (pass appName and navItems); past conversations and what the assistant remembers open in place from its toolbar (Back returns to the chat), on either surface. One request flows down a chain of std agent atoms on the bus: the conversation (std-agent-session) SENDs → CONVERSE → std-agent-context bounds it → std-agent-memory adds what it recalls → std-agent-tool-loop answers it through call-service llm call-tools, firing only the inputs and reading only the entities its tools allow, as the signed-in user → ASSISTANT_REPLIED goes back to the conversation, to memory (remembered) and to std-agent-trace (the run record). By default the tools are the program's own declarations: every -> external input (its @description is the tool text) and a read over every persisted entity, so composing building blocks composes the assistant's abilities. Any section's page gets the assistant with two traits, XAssistant = AgentSession.traits.AgentConversation and a std-panel-launcher dock: the conversation speaks the ASSISTANT_* contract from any orbital, so the assistant needs no per-section wiring. Import the orbital once per app: orbital Assistant = Agent.orbitals.AgentAssistantOrbital { config { instructions: "…" } }. The conversation, memory and run records live in AgentRecordsOrbital; retarget them onto your own owner-scoped entities (ownerId a relation to your [identity] roster, with @read/@create) with entities { AgentMessage: …, AgentMemory: …, AgentRun: …, AgentChat: … }. The conversation is kept across pages and reloads (each person's most recently used conversation is the current one);

Entity: AgentAssistant (runtime)

Traits

Config knobs

std-agent-builder

plan, build, validate, fix a single orbital end-to-end.

Entity: BuilderProcess (runtime)

Traits