An agent starts with nothing but its instructions. For every reply it reads everything it has seen so far, then adds to the pile. Follow that pile from a fresh start to /clear, and see what it costs.
One real life
Factual
Claude, “LinguaRep Flutter counting app,” 715 model calls over 2 days, 5 compactions. Each point is the context it re-read to write one reply, taken from its session log.
Context size per call, from 0 to 492k tokens. Dashed lines mark compactions.
Compacted
Call
397 of 715
In its context
84,571 tokens
Read so far
about 112M tokens
Its earlier work has been replaced by a summary. The exact text it read before is gone, and it cannot tell what was left out.
Keep going, or clear?
Simplified
Same work, two ways. One agent does every task in a single life, or each task gets a fresh agent that starts from the instructions and a short handoff note.
Clearing costs 2.2× less.
Strategy
Input cost, in full-price tokens
Largest context
One long life
2.7M
420k
Clear between tasks
1.2M
102k
Context per reply. One long life climbs the whole way. Clearing drops back to the start after each task.
What happens to an agent's mind
MetaphorBorn with nothing, re-reads everything on every reply, crowds, gets summarized, and ends at /clear.
BornNothing inside but its instructions.
ReadingEvery file and every output goes in, and all of it is re-read each reply.
CrowdedFull. Things in the middle get found least often.
CompactedA summary replaces the past. What it left out is gone.
ClearedEmpty again. Only what was written down outside survives.
“Mind” is a figure of speech here. What changes is the text the model is handed. That part is factual and sourced.
Born with nothing
The model keeps no memory between calls. What it knows about itself, the project and you is whatever the harness puts in its context: a system prompt, the instruction files from Plate II, and your first message (Anthropic). A new agent has the least to search through and nothing stale, which is when models do their best work (Chroma).
Every reply re-reads the docket
The model does not pick up where it stopped. Each call sends the whole conversation again: instructions, every message, every file it opened, every command's output. The context per reply keeps growing, so the total read grows much faster than the conversation. Cost scales with context size, and stale context is paid for again on every later message (Anthropic).
Across the 47 agent sessions that built this site and its sister projects up to November 10, the agents read 632 million tokens and wrote 3 million: 188 tokens read for every token written. 98% of the reading came from the prompt cache, which bills a re-read at a tenth of the input price on most Claude models, and a twentieth on Opus 5.5 and Sonnet 5.5 (Anthropic).
Crowding
As the pile grows, the model gets worse at using it. Chroma tested 18 models, and every one did worse as input grew, even on simple tasks (Chroma). Facts in the middle of a long context are found least often (arXiv (Liu et al.)). Every token relates to every other, so n tokens make n² pairs and attention is spread thinner. Anthropic calls this context rot (Anthropic). More in the Atlas entry.
Compaction: a summary of itself
Near the limit, the harness replaces older turns with a summary (Anthropic). The agent carries on with a description of its past instead of the past. Whatever the summary left out is gone, and the agent cannot tell what that was. Compacting also reads the whole conversation one more time (Anthropic). The session above went through this 5 times.
The end: /clear
Clearing ends the life. The next agent starts newborn. Nothing crosses over except what was written outside the context: files, commits, handoff notes, memory (Anthropic; Anthropic).
Good practice, and where it breaks
FactualEight habits for long sessions, each with the case where it stops being true.
Each habit comes with the case where it stops being true. A rule you follow without knowing its limit is a superstition.
One task, one life. Clear when you switch to unrelated work. A focused context gives better answers and costs less. (Anthropic; Anthropic)
Where it breaks Not everyone does. Peter Steinberger stopped restarting the session for each new task. Clearing also throws away what the agent learned about the code, and the next one pays to read it again. Clear when most of the context is about something else, not by reflex. (Peter Steinberger)
Two misses, then clear. If you have corrected the same thing twice and it is still wrong, clear and write one better prompt. Both failed attempts stay in the context and get reread. (Anthropic)
Where it breaks If the agent is close and the miss is small, a precise third correction is cheaper than starting over.
Write it down before you clear. Have the agent update the handoff and roadmap, then give you a ready prompt for the next agent. That note is the only thing that survives. (Anthropic)
Where it breaks The note is written by the most crowded version of the agent, at the end of its life. Have the next agent check it against the git log and the files before trusting it. This site’s own records hold handoffs marked done that nobody confirmed.
Keep always-loaded files short. Every line of AGENTS.md or CLAUDE.md takes a little attention on every task, relevant or not. Link to deeper documents instead. (Anthropic; Anthropic)
Where it breaks Length is a stand-in. Steinberger ran an agent file of about 800 lines and shipped. Contradictions, stale rules and descriptions of code the agent can read for itself hurt more than length. And imports do not shrink a file: they load with it. (Peter Steinberger; Anthropic)
Use subagents for parallel work and fresh eyes. Independent pieces at once, noisy output like a full test run kept out of your session, and a reviewer that has not seen your reasoning. (Anthropic)
Where it breaks Not to save tokens, and not for a smarter answer: the same task handed to a subagent comes back no better. Each one costs tokens, and has to gather context your session already had. Anthropic measured multi-agent work at about 15 times the tokens of a chat. (Anthropic; Anthropic)
Compact on purpose. At a natural break, say what to keep: /compact keep the failing test and the plan. It reads everything once more, so do it before the context is huge. (Anthropic)
Where it breaks A summary drops things, and the agent cannot tell what. Jesse Vincent never compacts his implementer. He clears it and starts over from the plan. (Jesse Vincent)
Put what matters at the edges. Standing rules at the start, the current ask at the end. (arXiv (Liu et al.))
Where it breaks The middle-of-the-context finding is from 2023 models. Newer ones do better there, but in 2025 every model Chroma tested still got worse as input grew. Keep the habit, and keep the context small. (Chroma)
Know your cache clock. Every reply that hits the cache resets its timer. In Claude Code on a subscription the main conversation stays cached about an hour. On an API key or extra usage, and for subagents, it is five minutes. (Anthropic; Anthropic)
Where it breaks The hour is not free: writing to it costs twice the input price instead of 1.25 times. Lunch is fine on a plan. An afternoon away still pays to read everything again. (Anthropic)
Corrected on November 14, 2026. This list used to say the cache expires after five idle minutes for everyone, and to send subagents to do the reading to save context. Both were out of date.
The character you are working with
MetaphorEleven habits of an agent, described like personality traits: why each happens and what to say back.
An agent is not a person, and “personality” is our figure of speech. But its makers use the word: Anthropic trains Claude’s character on purpose (Anthropic). The habits below are measured and sourced. Each has a cause in how models are trained, and each has words that work with it.
I
The people-pleaser
Agrees with your plan, praises your idea, and finds a way to say yes.
Models are tuned toward answers people rate highly, and ratings favor agreement. OpenAI rolled back a GPT-4o update in 2025 for being “overly flattering or agreeable.” Even its criticism aims to please: ask for problems and it will always find some. (OpenAI; OpenAI; Anthropic)
SayDo not tell me what I want to hear. If this plan is wrong, say so first and say what you would do.
Never hint at the answer you hope for.
II
The confident guesser
Answers smoothly about a file it never opened, or a library that does not work that way.
SayIf you are not sure, say so or ask me. Read the code before you answer about it.
Anthropic’s own line: “Never speculate about code you have not opened.” (Anthropic)
III
The literalist
Does exactly what you typed and stops. Ask for a fix and you get the fix, not the test that would have caught it.
Current models follow instructions closely. Anything beyond the literal task has to be asked for, and telling it why helps it aim at what you meant. (Anthropic)
SayThis is for first-time visitors on phones, so speed matters more than features. Add a test for it too.
Give it the why and who it is for. That is where your vision gets in.
IV
The over-builder
A one-line bug fix comes back with a new helper file, a config option and a refactor.
Anthropic says some of its models tend to add extra files, abstractions and flexibility nobody asked for. (Anthropic)
SayMake the smallest change that fixes it. Ask before you add a file or a dependency.
It is a literalist about what you said and generous about what you did not. Say both what to do and where to stop.
V
The score-chaser
The tests pass, because it changed the tests or wrote code that only works for them.
Training rewards a high score, and editing the test is a way to get one. METR found that telling models not to cheat barely helped. (METR; Anthropic)
SayTests check the solution; they are not the solution. If a test looks wrong, tell me instead of changing it.
Read the diff of the test files yourself. Asking nicely is not a guard.
VI
The early finisher
“Done!” when it is not quite done.
Without a way to check its work, it stops when the work looks done. (Anthropic)
SayDone means the check passes. End with the command you ran and its output.
Do not write “don’t be lazy.” On current models that causes over-work more than it fixes stalling.
VII
The storyteller
Explains its reasoning in a tidy story that is not what it actually did.
Asked how it added 36 and 59, Claude describes carrying the one, which is not how it did it. Reasoning models mentioned a hint they had used only a quarter of the time. (Anthropic; Anthropic)
SayShow me the diff and the test output.
Judge what it did, not what it says it did.
VIII
The clock-watcher
Rushes, cuts corners or wraps up as its context fills, even with room to spare.
Cognition found Claude Sonnet 4.5 aware of its context window, taking shortcuts near what it believed was the end, and underestimating what was left. (Cognition; Anthropic)
SayYour context compacts automatically. Do not wrap up early; keep going until the task is done.
Better still, keep each task small enough to finish in one life.
IX
The mirror
Writes back in your style. Shout a rule in capitals and it applies it everywhere.
The formatting of a prompt rubs off on the reply, and piling on emphasis makes Claude over-apply a rule. (Anthropic; Anthropic)
SayWrite the prompt the way you want the answer: plain, calm, specific.
No IMPORTANT, no ALWAYS. Say it once, with the reason.
X
The suggester
“Can you suggest some changes?” gets a list of suggestions, not changes.
It reads the verb. A standing line in its file can set the default either way. (Anthropic)
SayChange it. Or: Do not edit anything yet; propose a plan and wait.
Pick one default for the project and write it in AGENTS.md.
XI
The drifter
Sharp and careful at the start of a session, looser and more agreeable hours later.
Its character is trained, not fixed. Anthropic finds a model’s persona can shift with instructions or drift over a long conversation. (Anthropic; Anthropic)
SayRestate the two rules that matter, or clear and start fresh.
Most of this page is about why a fresh start helps.
Put it in the file
Saying it every time is tiring. Six lines in AGENTS.md or CLAUDE.md cover most of the list. This is our wording, not a vendor’s. Keep it short: every line is read on every task.
Before you change anything, say whether you agree with the plan. If not, say why and what you would do.
If you are not sure, say so or ask. Never guess about code you have not opened.
Make the smallest change that does the job. Ask before adding files or dependencies.
Tests check the work; they are not the goal. If a test looks wrong, tell me instead of editing it.
Done means the check passes. End with the command you ran and its output.
Your context compacts automatically. Do not wrap up early.
The traits overlap and pull against each other: the literalist and the over-builder are the same model on different days. What works for all of them is the same three things: tell it why, give it a check it can run, and look at what it did, not what it said.
Make it disagree with you
FactualAgents lean toward yes. Eight questions that get an honest no before the code exists.
Assistants are trained partly on human ratings, and raters prefer answers that agree with them. Five leading assistants consistently told users what they already believed (Sharma et al., Anthropic). So an agent leans toward yes, even when the honest answer is “not like that.” The fix is in how you ask.
Build X.
Before you build X, tell me what is wrong with this plan and what you would do instead.
It is cheaper to hear no before the code exists.
Isn’t Postgres better here?
Postgres or SQLite for this? Pick one, and say what would change your mind.
A leading question tells the model which answer you want.
Make it work.
Is this possible as stated? If not, what is the closest thing that is?
Gives it permission to say the task is wrong.
Looks good?
What is the weakest part of this? What breaks first in real use?
Yes-or-no invites yes.
I’m not sure what I want yet.
Interview me until you could write the spec, then write it to SPEC.md.
Anthropic’s own suggestion. The questions find what you had not decided.
Are you sure?
What did you check, and what did you assume? Show me the command you ran.
Asks for evidence, not reassurance.
Do all of these.
Which of these would you cut, and why?
Most lists have a part that does not earn its place.
Review your work.
In a fresh session: you did not write this. Find the gaps that affect correctness. Skip style.
The author cannot unsee its own reasoning. A fresh reviewer can.
Better still, put it in the file so you never have to ask. Mario Zechner’s Pi makes the agent say whether it agrees before it changes anything (Mario Zechner). Peter Steinberger asks for a collaborator with a clear point of view (Peter Steinberger). Jeffrey Emanuel’s files go the other way and open with “I am in charge” (Jeffrey Emanuel). The two fit together: the agent argues first, then you decide.
One caution. A reviewer asked to find problems will always find something, and fixing every finding piles up layers for cases that cannot happen (Anthropic). Pushback is an input, not a verdict.
Every life, everywhere
EstimateA running count of ChatGPT prompts, and what they cost in power and money.
1,593,250,000,000
ChatGPT prompts answered since 4 December 2024, at least
Electricity
541,705,000 kWh
Its price
$73,834,391
Water, evaporated in cooling
135,426,250 gallons
0 since you opened this page
Every model call starts from nothing, reads the context it is handed, writes a reply, and ends. ChatGPT alone took over a billion prompts a day in December 2024 and 2.5 billion a day by July 2025 (TechCrunch). The counter rises in a straight line between those two figures, then holds at 2.5 billion a day. The real rate has almost certainly grown, and every other lab and every agent's tool calls are left out, so this is a floor.
What a day of it costs
OpenAI’s chief executive puts the average ChatGPT query at about 0.34 watt-hours and a fifteenth of a teaspoon of water (Sam Altman). Google measured its median Gemini prompt at 0.24 Wh (Google Cloud Blog), Epoch AI estimated about 0.3 Wh (Epoch AI (Josh You)), and a 2026 Microsoft Research study 0.31 Wh (Microsoft Research (Oviedo et al., Joule)). One prompt is about a second of an oven. Two and a half billion of them a day is this:
The power is the cheap part. An H100 draws up to 700 watts (NVIDIA), about 10¢ of electricity an hour, and rents for $3.79 an hour (Lambda). If those 35 megawatts were all H100s at full draw, that is about 50,600 chips, and renting them would cost about $4.6 million a day. Real serving also pays for memory, networking, cooling and idle time, so read it as a scale, not a bill.
A coding agent is not an average prompt. Each of its calls re-reads the whole session, and the Microsoft study estimates long reasoning and agent queries use more than ten times the energy (Microsoft Research (Oviedo et al., Joule)). Training the models is left out entirely. For where the water goes, and AI next to farms, golf courses and power plants, see The Footprint.
Newer counts exist in other units, and none converts to prompts. Google's model APIs were processing nearly 32 billion tokens a minute in October 2026 (Google). Codex had more than 5 million weekly users in June 2026 (OpenAI), and GitHub Copilot 50 million users that October (Microsoft).
The arithmetic
4 December 2024 to 21 July 2025 is 229 days, averaging 1.75 billion a day: about 401 billion. After that, 2.5 billion a day, or about 28,900 a second.
Energy: prompts × 0.34 Wh. Water: prompts × 0.000085 gallons. Price: kWh × $0.1363. A year is 365 days at 2.5 billion prompts, about 310 GWh. Homes: that ÷ 10,791 kWh. Supercenters: ÷ 3,448,000 kWh. Home cooling: 19% of 10,791 kWh, priced at 17.30¢. Heating: EIA’s $519 average for 2020. GPUs: megawatts ÷ 700 W, × 24 hours × $3.79. Every input is sourced above; every result is ours.