Agents, context, and cost

Back to the stack. We have covered company and model. Now: agents, context, and cost. What does an agent do that a chat doesn't? Why does the model “forget” everything? Why do long sessions cost more?

The same task, two ways. With a chat, you carry the code to Rhino, bring the error back, paste it again: four trips, and the chat never touches Rhino. It's the consultant who answers and leaves. With an agent, you ask once: the agent reads the layers, runs, sees the error, fixes it and finishes. It's the assistant with a checklist. In a chat, you are the loop; in an agent, the loop is part of the program. What makes it possible: tools, a loop, and verification.

Agent

A model inside a program that gives it tools and a loop: it decides a step, runs it, reads the result and continues until the task is done.

Four pieces and one wire. The model decides the next step, the tool acts, the result comes back and the model observes it. Lap one: it asks for the list of layers. Lap two: it runs the script and fails; the error is information too, it goes back to the model. Lap three: it fixes it, it works, and since it's done, it exits with the answer. The key point: the model never runs anything, it only writes text asking for a tool. The one that runs it is the harness, the program around it. What's inside the harness? That's next.

Tool

An action the agent can request: read a file, run a script, query Rhino. The model asks for it in writing; the harness runs it.

We open the harness. Memory: notes that survive between sessions, like the project log; the model remembers nothing. Instructions: the fixed rules before every task, the office standards manual. Workspace: the folder you hand over; whatever isn't there doesn't exist for it. Tools: the actions it can request; the model asks in writing and the harness runs them. Skills: packaged instructions; it only sees each one's title and opens the one it needs, like the index of a procedures binder. MCP: a standard plug for adding more tools, covered in Part 3. An agent is only as good as its harness and its model: ChatGPT and Lattice can use the same model, but only one has tools that touch your Rhino file.

Memory

Notes the harness saves and reads back between sessions. The model by itself remembers nothing.

System instructions

Fixed rules the agent receives before every task: its role, its style, and what it must never do.

Workspace

The files and folders an agent can see and change.

Skill

A package of instructions for one specific job. The agent only sees its title and opens it when the task needs it.

The model remembers nothing between messages. Every turn, the harness builds a package with everything: the instructions, the tool list, every earlier message, every reply and every result, and sends it whole. The model reads it, writes one reply and forgets it. It's a colleague with total amnesia who re-reads the whole project file before every sentence. That's why each turn costs more than the last. When the package no longer fits in the context window, the harness summarizes or trims the old parts, and something is lost. For you: long sessions cost more, clutter makes results worse, and it pays to start a new session for each task, with short instructions, files instead of walls of text, and only the tools you need. Illustrative sizes and price.

Type any sentence and see how it splits into tokens. It's an approximation: each model has its own way of cutting text. Spanish usually takes more tokens per word than English, so the same work costs a bit more. Code is tokens too: every symbol counts. And input and output are billed separately: what you send, including the whole context, is cheap; what the model writes, including its reasoning, costs about five times more. Rule of thumb: a token is about three quarters of an English word, and a thousand tokens is roughly a page.

Input and output tokens

Input: everything sent to the model, including the context. Output: what the model writes. Output costs several times more per token.