Glossary
Every other sheet on this site assumes you already know what a model is and roughly what a harness would be. This one does not. Twenty-one words, in plain language — and an argument that they are not a list. Read from the bottom up: each one exists because the one below it ran out of road. The two everybody asks about, Bedrock and OpenRouter, turn out not to be on that ladder at all.
The ladder — why there is more than one word for this
A model is a file of numbers that guesses the next piece of text. It remembers nothing, so a chatbot re-sends the whole conversation every turn to make it look like it does. A chatbot can only describe the work, so an agent hands the model real tools and loops on what comes back. And an agent acting on its own is only as good as what surrounds it — which is a harness.
Four words, one chain. Nobody added a rung for the pleasure of it: each one is there because the layer beneath it hit a wall, and the wall is the interesting part. That is the same shape the rest of this site is built in, one level further down.
One turn, taken apart — what the arrow actually carries
The third rung is the one people repeat most and inspect least. An agent is a model in a loop with tools — which sounds like a machine that has been switched on and is now running. It isn’t. Between turns nothing of it is alive. Each turn is a fresh call to a component that remembers nothing, handed a fresh copy of everything it is supposed to know. The loop is continuity performed from the outside, one turn at a time.
- The question it raisesWhat goes in, and who decides
Reason — decide the next step
The model is handed everything it is meant to know for this turn: the standing instructions, the conversation so far, whatever files someone included, and the result of every tool call before this one. It returns one thing — an answer, or a request to run a tool. Nothing carried over on its own; it was re-sent.
- The question it raisesWhere the command actually runs
Act — call a tool
The model does not run anything. It asks. What happens next is the harness’s call: whether to honour the request at all, where the command executes, with what access, and whether a human is asked first. This is the step where a wrong turn stops being a wrong sentence and starts being a changed file.
- The question it raisesKeeping the trail from eating the window
Observe — read the result
Whatever came back — a diff, an exit code, a stack trace, forty thousand lines of log — is written into the trail as text, because text is the only thing the next call can be shown. The loop’s own output is now competing for room with the work.
- The question it raisesWhat is left when the process dies
…and again — the turn ends, the model stops existing
The next turn gets exactly what the harness chose to carry across, and nothing else. That is why memory, compaction, and anything that survives a crash at turn nine are engineering problems rather than model features — and why something outside the loop has to decide when it is finished.
Now run that cycle a hundred times, and draw it flat instead of round. The circle flatters the machine — it looks like something switched on and humming. Unrolled, an agent is a row of separate calls to an identical component, each one handed a taller stack than the last, with the loop’s own output in it.
Nothing in that cycle is the model’s decision. Somebody chose what went in, which tools existed, which of them ran without asking, what was kept, and what would make the loop stop. Leave any of it unset and the choice still gets made — by a default, quietly, on every turn. That is the harness, and it is why a failing agent is so rarely a failure of the model.
The question the ladder never answers
Every rung above assumes some model is reachable. None of them say whose, or where it runs. That is a different question, and confusing the two is the single most common way this vocabulary goes wrong: Bedrock and OpenRouter are not rungs on the ladder. They are the socket the bottom rung plugs into.
Call a provider directly and you have one key and one company’s models. Call through Bedrock and the same request runs inside an AWS account, under its identity, regions, and bill. Call through OpenRouter and one key reaches many providers, with routing between them. Three paths, one port — and the harness on the other end cannot tell the difference.
Which is the payoff: swapping the socket does not change the ladder. A harness that checks its own work is a good harness whichever way the tokens arrived, and one that doesn’t stays fragile behind the best model on the market.
Band 01 — The material
What is actually there when you strip the product away: a file of numbers, the text you feed it, and one run of the thing.
A file of numbers learned from training, plus the code that runs it. Show it text, it hands back a guess at what comes next.
That is the whole of it. The file has no memory of your last message, no way to open a file or send an email, and no ability to start itself. It sits there until something calls it.
Everything you have ever interacted with — the chat window, the coding agent, the assistant in your editor — is a wrapper around that call. The interesting engineering is almost entirely in the wrapper.
Commonly confusedA model is not a product and not an assistant. It is a component, and the least replaceable-looking part of the system is in fact the easiest one to swap.
Runs out of roadOne guess is not a conversation. Nothing inside the file remembers what you said a moment ago — so something outside it has to.
A model trained on an enormous amount of text to predict what comes next. “Large” describes its size, not its judgement.
The prediction framing sounds reductive, and it is worth holding onto anyway: an LLM is doing one thing repeatedly, and the fluency is a consequence of doing it well across a very large amount of text.
Practically, this is the model class every agent on this site is built around — it takes text in, returns text out, and can be taught what to do by the text you send it rather than by retraining.
Commonly confusedNot every model is an LLM. Embedding models, classifiers, speech models, and image models are models too, and several of them show up inside a working harness.
The numbers adjusted during training. They are the model — there is nothing else in the file that counts as knowledge.
When a model is described by a number of billions, that is a count of these. It is a rough measure of capacity, in the way that engine displacement is a rough measure of a car.
The weights are fixed once training ends. A model that “learned” something from your conversation did not: the wrapper showed it that something again, in the text, on the next call.
Commonly confusedWeights do not update while you talk to a model. Anything that behaves like learning is being done by a layer outside the file.
- Taught properly onWhat to do when the budget is finite
The chunk a model actually reads and writes — roughly a word or a piece of one. Everything gets counted, billed, and limited in these.
Models do not see letters or words; they see tokens. A common English word is usually one token, a long or unusual one splits into several, and whitespace and punctuation cost too.
This matters because every limit you will meet is expressed in tokens: how much you can send, how much comes back, and what it costs.
- Taught properly onSelect, compress, write, isolate
How much the model can be shown at once, counted in tokens. Full is full.
Everything the model knows on a given call is inside this window: the standing instructions, the conversation so far, the files someone pasted in, the results of every tool it has run. Nothing outside it exists.
A large window is not the end of the problem. Attention is not free, and what sits in the window competes for it — which is why deciding what goes in is a design job with a whole sheet of its own.
Commonly confusedMore context is not better context. Filling a large window with everything available reliably makes an agent worse, not better.
One run of the model: text in, text out. It knows only what this one run was shown.
Inference is stateless. Two calls a second apart share nothing unless the second one was handed the contents of the first.
This single fact explains most of what a harness does. Memory, conversation, long-running work, and progress that survives a crash all have to be built outside the call, because the call itself forgets everything the moment it returns.
- Taught properly onThe first layer, and where it stops
The text you send. The system prompt is the standing part of it: who the model is, what the rules are, what the work looks like.
Because the weights are fixed, the prompt is the main way to change behaviour. In a real harness it is not one hand-written paragraph — it is assembled, on every call, out of standing rules and whatever the situation calls for.
The standing part is the first harness layer, and it has a limit built into it: it can say “follow the project conventions,” but it cannot go and find them.
Band 02 — The wrappers
Everything built around that file to make it useful — and the ladder those wrappers climb, one rung per limitation.
- Taught properly onWhat the transcript really is
A transcript-keeper. It re-sends the whole conversation on every turn, so a model that remembers nothing appears to remember you.
That is the entire trick, and it is worth being unimpressed by it on purpose: the model does not recall the earlier messages, the wrapper re-reads them aloud each time.
It follows that a long conversation costs more than a short one, and that a conversation which outgrows the window has to start dropping or summarising its own past — which is where memory stops being free.
Commonly confusedA chatbot is not an agent. It can describe the fix, name the file, and write out the command — but it cannot run it.
Runs out of roadWords about the work are not the work. To change anything, the model’s request has to reach something that can act.
- Taught properly onThe contract, and what it constrains
A named action with a described shape, which the model can request instead of describing.
You give the model a list: here is `run_tests`, here is what it does, here are the arguments it takes. The model replies with a request to call one of them. It does not execute anything — it asks.
Everything after the asking belongs to the harness: running it, deciding where, deciding with what access, and handing the result back.
- Taught properly onWhere tools sit in the stack
A shared standard for exposing tools, so one server can be used by any agent that speaks it.
Before a standard existed, every tool had to be wired into every agent by hand. MCP makes the connection generic: a service author writes one server, and any harness that speaks the protocol can offer those tools to its model.
It is plumbing, and it is the reason the ecosystem grew as quickly as it did.
Stated by its makers, not by us — modelcontextprotocol.io
- Taught properly onThe eleven slots, as a map
A model in a loop with tools: decide, act, read the result, decide again — until the work is done or something stops it.
The loop is the definition. Not autonomy, not intelligence, not how impressive the demo was. A system that calls a tool, feeds the output back into the next call, and keeps going is an agent; one that answers once and stops is not.
Nothing about the model changed to make this possible. The same stateless call sits at the middle of it, being re-invoked. What changed is that its request now reaches something that can act, and that what comes back is written down where the next call will see it.
That is also the whole of its “autonomy”. An agent is not deciding how much freedom it has — somebody decided which tools exist, which ones run without asking, and what would make the loop stop. Left unset, those decisions are still made; they are just made by default.
Commonly confusedAn agent is not a harness. The agent is the loop; the harness is everything that makes running the loop survivable.
Runs out of roadA loop that can act unattended is only as good as what surrounds it — what it was told, what it was shown, where its commands run, and what it can prove afterwards.
- Taught properly onThe loop, drawn and taken apart
The turn cycle itself: the model decides, the harness executes, the result comes back, and the whole thing starts again with that result added.
Drawn out, it is four boxes and an arrow returning to the start — reason, act, observe, and a model in the middle being called again. The picture is simple enough that it looks like it explains itself, which is exactly the trap.
The trap is that the arrow is not free. Nothing loops on its own: at the top of every turn something has to assemble, from scratch, everything the model is supposed to know — because the call it is about to make remembers nothing of the last one. The loop is continuity performed from the outside, one turn at a time.
So every question this site asks lives on that arrow. What gets carried into the next turn and what gets dropped. Where the command in the middle of it actually ran. What is left if the process dies at turn nine. Whether anything checked that the result it just read was true. Answer those badly and the loop still runs — it just runs somewhere you did not want to go, quickly, and bills you for the trip.
Commonly confusedThe loop is not one long call with the model thinking throughout. It is many separate calls. Between turns nothing of the agent is running; it is re-created each time out of text.
Runs out of roadEvery turn adds to the trail, and the trail is what the next turn is shown. Left alone, the loop fills its own window with its own history and starves the work of room.
- Taught properly onKeeping the trail from eating the window
One trip around the loop: one call to the model, at most one action, one result written down.
It is the unit everything on this site is measured in. Context is assembled per turn, tokens are spent per turn, and a crash happens between two of them rather than in the middle of one.
Each turn is handed the accumulated trail of the ones before it, which is why a long-running agent gets more expensive and less focused as it goes unless somebody intervenes. The transcript is both its memory and its ballast.
Commonly confusedA turn is not a conversational exchange with you. An agent can take dozens of them between one instruction and its answer, and you may see none of them.
- Taught properly onHow you would know it went wrong
Whatever makes the loop end: the work is finished, a limit is hit, a human says no, or nothing does and it spins.
A loop with tools is a program that writes its own next instruction, so “done” is not something the model can be trusted to declare on its own. Real systems bound it from outside — a turn count, a token budget, a wall clock, a gate that needs a human before certain actions.
This is the least glamorous entry in the register and one of the most load-bearing. An agent that cannot finish is only an inconvenience; an agent that cannot stop repeats a failing action confidently, at machine speed, against real systems.
Commonly confusedFinishing is not the same as succeeding. A loop can hit its stopping condition perfectly and still have done the wrong thing — which is why the sheet that owns this is about proof, not about exits.
- Taught properly onStart at the first slot
Everything around the model that turns a loop into something you would let run unattended.
Instructions, the material it gets shown, what it can call, where those calls run, what survives the turn, who coordinates the work, and what proves it worked. Eleven slots, each one a decision somebody makes — deliberately or by default.
The word is load-bearing here because it relocates the question. When an agent does something stupid, the reflex is to blame the model. Nearly every time, one of these layers ran out of road, and the model was working from what that layer handed it.
Commonly confusedA bigger model is not a fix for a harness failure. If the agent never saw the file, no amount of capability recovers it.
Band 03 — The supply seam
Whose weights, and where they run. A different question from the ladder, and the one most often confused with it.
Someone else runs the weights on their hardware; you send text over the network and pay for the tokens.
Almost nobody holds the file. You hold a key, you post text to an address, and text comes back. Everything on the ladder above sits on top of that one call.
Which means the ladder has said nothing at all about whose model it is, or where it runs. That is a separate question, and the next two entries are the two most common answers to it.
Commonly confusedAn API key is not an architecture. Access is a config line; the layers are the design.
- Taught properly onWhy boundaries are their own layer
AWS’s managed way to call models from several providers through AWS’s own API, credentials, regions, and bill.
Bedrock is not a model. It is a place to reach models from inside an AWS account, which is the point of it: the same identity system, the same billing, the same region and networking controls you already govern everything else with.
For an organisation whose compliance story is written in AWS terms, that is the whole argument. The seam moves inside the perimeter.
Commonly confusedBedrock is not an agent framework and not a model of its own. It is a way of calling other people’s models.
Stated by its makers, not by us — AWS documentation
An independent service that puts one API and one key in front of many providers’ models, and can route between them.
Same category as Bedrock, different argument. Instead of moving the seam inside a cloud account, it collapses many providers into one interface, so trying a different model is a change of string rather than a change of integration.
What you gain is reach and easy comparison. What you take on is another party in the path between your harness and the weights — which is a real consideration, not a disqualifying one, and the kind of thing to decide deliberately.
Commonly confusedOpenRouter is not a model, and not a cloud. It is one key in front of many providers.
Stated by its makers, not by us — OpenRouter documentation
- Taught properly onImproving the harness, not the model
The category both of the above belong to: the seam where “which model” becomes a configuration value instead of an architectural commitment.
From the harness’s point of view, a direct provider call, a Bedrock call, and an OpenRouter call are the same shape. Text goes out, text comes back. What differs is who is in the path, whose bill it lands on, and what governs it.
This is the payoff of separating the two axes. Swapping the socket does not change the ladder: a harness with a real verification layer is a good harness whichever way the tokens arrived, and one without stays fragile no matter how good the model behind the gateway is.
Band 04 — The words this site made load-bearing
Two pieces of vocabulary used on every sheet. Short entries; the sheets do the teaching.
- Taught properly onAll eleven, in order
Primitive
#One of the eleven slots every coding agent needs an answer for, whether or not anyone decided it on purpose.
Used throughout the site in place of “component” or “feature”, because a slot can be filled, adapted, or deliberately left empty — and an empty slot is still an answer.
- Taught properly onThe first wall, and what it forces
Runs out of road
#What this site says instead of “limitation” — the exact point where a layer stops working and the next one has to exist.
Every sheet ends by naming it. It is the site’s spine, and the reason the material is a traversal rather than a reference: each primitive is there because the previous one hit a wall.
Eleven things this vocabulary is not
A model is a product
It is a file plus a runtime. Everything you interact with is a wrapper around it.
Every model is an LLM
Embedding, classification, speech, and image models are models too, and a working harness usually holds several kinds.
A chatbot is an agent
A chatbot describes the action. An agent requests it, and gets the result back to work from.
An agent is a harness
The agent is the loop. The harness is everything that makes running the loop survivable.
The loop is one long call
It is many separate calls. Between turns nothing of the agent is running — each turn re-creates it out of text somebody chose to send.
An agent is autonomous by nature
Autonomy is a setting. Which tools exist, which run without asking, and what makes the loop stop are all decisions somebody makes — or leaves at their default.
Bedrock is a model
It is a way of calling other people’s models inside AWS.
OpenRouter is a model
It is one API key in front of many providers.
An API key is an architecture
Access is a config line. The layers are the design.
More context is better context
Attention is finite. Wrong context is worse than missing context, which is why managing it is its own layer.
A bigger model fixes a failing agent
When an agent fails, don’t ask was the model good enough — ask which harness layer ran out of road.
That is the whole vocabulary. Everything after it is one layer at a time: eleven slots that every coding agent needs an answer for, starting with the one that shapes all the others and cannot do anything on its own.
01You now have the wordsThe Harness — Instructions, the first slot