
The agent action loop and how it stops
The loop is the mechanism; the stopping condition is the control that bounds it.
Serving a model and using it: compatible APIs, the request envelope of prompts and system instructions, streaming, retries and structured JSON output.

The loop is the mechanism; the stopping condition is the control that bounds it.

How a multi-agent system is wired: fan-out, isolated workers, fan-in and partial failure.

A cache is a bet the input repeats; invalidation is the price of being wrong.

Not model power but control: who picks the next step — the code, the model, or no one.

A chunk is the unit of retrieval, of context and of citation; its size decides all three.

Why a tool server is a separate process with its own client, channel and handshake.

Batching, queueing and backpressure: running many model calls within one pool.

Retrieval gives a list, assembly gives a context, citations give a verifiable pointer.

A long workflow outgrows its window: what stays, what is compacted, what must survive.

Model, cache and context choices set unit cost — and a measured number does not transfer.

Preparation decides what a retriever can find; extraction errors become missing answers.

Dense retrieval misses exact tokens; hybrid search merges two rankings and needs a filter.

MCP separates the host that coordinates, the server that exposes, and the data it shares.

Choosing where a request goes: model and provider selection, router logic and its limits.

What a component boundary buys, where state lives, and why such systems fail as one.

How an agent splits a goal into subtasks — and when the split should stay fixed in code.

A reranker reorders a short list accurately; it cannot create what the first pass missed.

Timeouts, retries and backoff bound an agent loop before one failure becomes an outage.

The model proposes, the orchestrator decides, the executor acts: three separate roles.

A finite context window forces every LLM system to decide what to remember.

Agent state as a checkpoint: what survives a crash, and what re-runs on resume.

Delegation buys parallel context windows, and bills you in tokens and coordination.

A tool call is a proposal with three artefacts: the declaration, the call, the result.

A tool schema steers the model and checks the call — two jobs, one contract.

A vector index buys speed by giving up exactness; knowing which one decides its limits.

Fixed code paths win when the steps are known; a model loop wins when they are not.

A serving engine adds a queue, a lifecycle and an API surface to a weights file.

The model sees what the envelope builds: template, budget and stopping conditions.

Streaming changes when you know; idempotency decides whether you may ask again.

Asking for JSON and constraining the decoder to JSON are two different guarantees.

Who chooses the next step: the model, the application around it, a workflow or an agent.

The model file, the engine that runs it, the product around it — and what a symptom means.

What a prompt and a system instruction are, and why an instruction is not a control.