The Words

the thing that owns a loop and survives between runs: an identity, a set of tools, a memory, a policy, and triggers. Not the model.

the mechanism: the model replies, the runtime acts on the reply, the result goes back into context, and the model replies again until it returns an answer.

one trip through the loop, from a cold trigger to a committed result. It starts and it ends.

one trip around the ring inside a run. Every pass is exactly one model call.

an ambiguous word. Some people mean one model call, some mean one user-and-assistant exchange. This site says pass for the first and exchange for the second.

a shape where code decides the steps and the model fills them in. Prompt chaining, routing, parallelization. You can draw it before it runs.

your code around the model. It wakes the loop, builds the context, reads the reply, executes the tools, checks the budget, validates the output, writes the result. Everything that is not step 04.

another word for the runtime, used when the emphasis is on the code that holds the model in place and feeds it. Same thing.

a runtime, or an agent, whose tools are other agents. It decides what to delegate; each worker runs its own loop.

the neural network that reads a context and writes a reply. It has no memory, no network, no hands. Step 04 and nothing else.

large language model. The model. The letters do not add anything.

one model call: context in, reply out. The only thing that costs tokens.

the unit the model reads and writes, roughly three quarters of a word in English. Cost, limits and the context window are all counted in tokens.

everything sent to the model on one pass: system prompt, tool definitions, retrieved documents, prior messages, and the live input at the tail. Rebuilt every pass.

the maximum number of tokens one pass can carry. A size limit, not the content.

the standing instructions at the front of the context: who the model is, the rules, the format. The seat file, in this house.

loosely, whatever you send the model. Precisely, the whole context. When someone says the prompt they usually mean the system prompt or the last user message; ask which.

the field on every reply that says why the model stopped: it wants a tool, it is done, it hit the token cap, or it refused. The runtime routes on this.

the model reasoning to itself before the reply. Happens inside step 04; changes cost and quality, not the shape of the loop.

receiving the reply as it is written instead of all at once. A delivery detail of step 04.

reusing the front of the context across passes so the static part is not paid for again. Why static content goes first.

a function the runtime can run on the model's behalf. The model sees its name, description and input schema; the runtime holds the code.

the JSON the model is shown: name, description, input schema. Part of the context. Not the code.

the block the model writes when it wants a tool: which tool, with which arguments. A request, not an execution.

what the runtime sends back after running a tool, as text, in the next message. Errors ride the same way.

the API feature that lets a model emit tool requests. One call with one request and no loop is function calling; a loop makes it an agent.

the runtime reading the tool requests and running each one. Step 06. Never the model.

several tool requests in one reply, run side by side, all returned before the next pass. One agent, one pass, several legs.

human in the loop: a person approves, edits or denies a tool request before it runs. Sits on the legs you mark, usually writes and money.

Model Context Protocol. A standard way for a runtime to discover and call tools that live in another process or server. Tools by plug rather than by code.

retrieval augmented generation: fetching documents and putting them into the context before the model call. One way of doing step 02. Not a step of its own.

whatever wakes a run: a cron tick, a queue row claimed, an inbound message, a webhook, a user pressing send. Fires once.

a clock that fires a trigger on a schedule. Six pm every day, every five minutes.

an outside service calling a URL of yours when something happens. A trigger you did not schedule.

a list of jobs waiting to be run. A worker claims a row and that claim is the trigger.

the guard before every model call: passes, tokens, dollars, seconds. Over the ceiling ends the run without spending the call.

the ceilings the breaker enforces. Per run and per day.

checking the final answer against a schema before anything downstream reads it. Bad output bounces back for one more pass.

forcing the reply into a fixed JSON shape, usually by giving the model a tool whose input schema is the shape you want.

checks on what goes in or comes out. Input guardrails live at context, output guardrails at validate. A vague word; ask which.

the end of a run: write the result, respond, release the lock, log the cost.

a store the runtime writes at commit and reads at context. The model itself remembers nothing between passes.

everything about the agent that persists between runs: memory, settings, the ledger. Lives in the runtime, never in the model.

the row written per run that says what it cost: tokens in, tokens out, dollars, passes. The proof a run happened.

the door you call the model through over the network. For this house, the Anthropic Messages API: one request with a context, one response with a reply.

a library that wraps the API in your language so you do not write HTTP by hand. The Anthropic SDK also ships a tool runner, which is a ready-made loop.

who serves the model: Anthropic, Google, xAI. This house puts them behind one adapter so the run does not care.

this house's rule: code runs the queries and hands the agent everything at once, before the model call. Tools before the model, zero tool requests during.

this house's word for one agent's standing identity: who they are and which model serves them. One file per seat.

an agent started by another agent, run to completion, and returned as a result. To the parent it is a tool.

any shape with more than one loop: orchestrator and workers, crews, swarms. Usually one orchestrator and several subagents.