What a turn sends

One turn is one request. This page opens one up: what travels, what each part of it costs, and what the next turn gets back without paying for it again.

These are the shipped defaults. What you can change lives in a config file you own once TESSERACT is installed, so your copy may differ, and should, once you tune it.

A request is two fields, and only one of them is prose

Everything the assistant is told arrives in one of them. Who it is, what it has been told to keep about you, what was recalled for this question, what happened while you were away: all of that is writing, and writing turns into tokens at a steady rate, about 3.32 characters to one here. That figure is measured against this runtime’s own history rather than assumed.

The tools arrive in a second field, and that one is not writing. It is a list of definitions: names, inputs, types, one nested inside another. What it costs has very little to do with how long it is, for the reason two sections below, so counting its characters gives an answer that is wrong by a multiple rather than by a margin.

Both are priced in one place, so the cockpit, Conscience and a reply on a channel quote the same number. They used to quote three different ones.

What the first field is made of

Block	What it is	Between turns
OPERATING.md	How it works: the rules it follows on every turn.	held
memory capsule	The small memory bootstrap it starts the conversation already holding: your curated MEMORY.md and the last two daily captures.	held
saved directives	Standing instructions you saved that are not switched on right now, listed so it knows they exist.	held
SOUL.md	How it sounds, and the register it holds to.	held
pointers	A list of the files and skills it can open on request, so it knows what exists without carrying any of it.	held
USER.md	What it has learned about you, and keeps.	held
the tool map	Every tool it has, one line each, grouped by the question each one answers, left out for a model that finds tools itself.	held
surface contract	What this surface cannot physically carry, and nothing else.	held
this chat	Which conversation this is, and which surface it is running on.	held
OUTPUT-CONTRACT.md	The parts of a reply and where each one goes, so every surface shows and speaks it the same way.	held
projects	Which projects are open, which one you are working in, and where that one lives on disk.	rebuilt
autonomy digest	What it has open on its own agenda, and anything that has been failing.	rebuilt
room left	How full this conversation is, and where its soft and hard limits are.	rebuilt
voice	Whether the operator hears this turn, so the spoken line is written only while they do.	rebuilt
date & time	Today’s date, the local time, and how long this instance has been running.	rebuilt

The held blocks are read once, when a conversation starts, and those same bytes are sent for the rest of it. A document you edit in the middle of a conversation is read by the next one. That is deliberate rather than a delay: fetching the file again to deliver it would cost the whole reused part of the request, to say something the assistant has already read a few messages above.

Five blocks are rebuilt instead. Autonomy digest, room left, voice and date & time differ on every single turn by definition. The block for projects could be held and deliberately is not, so that a change there reaches the next turn rather than the next conversation. All of them are sent after the conversation and after your own message, at the point where what they change has nothing behind it to spoil.

The second field, and why its length tells you nothing

What	Amount
the whole list, in characters	208,155
the part of it that is charged for, in characters	55,419
what it costs, in tokens	16,713
one tool on the working set, on average, in tokens	393
the same tools with every one described in full, in tokens	59,327

The figures above price a definition at the rate prose runs at, about 3.32 characters to a token. That is an estimate and it reads high, which moves a conversation to its ceiling earlier than it needs to rather than later. Once the model has answered, the app uses the provider’s own count of the whole request instead.

39 of the 175 tools travel as full definitions, because they are the ones on your working set. The other 136 travel inside 24 group entries, and a group entry is a name and a sentence about what is in it. The definitions inside one are there for the assistant to read and the provider charges nothing for them, which is the whole of the difference between the last two rows above.

Three of the 27 groups do not appear at all, because every tool in them is already on your working set.

The groups are the same headings you read down on Tools. The shape of that page and the shape of the request are one list, not two.

Where a tool outside the working set actually arrives

A group entry is not a smaller definition. It carries no inputs, so nothing in it can be called from the entry itself.

When the assistant needs something from a group, the provider matches the group on its own side and appends that one tool’s full definition at the end of what it is reading, after the conversation and after your message. It does not go back and rewrite the tools field. Nothing in front of the new arrival moves, which is why reaching for an unfamiliar tool halfway through a long conversation does not cost that conversation everything it had stored.

On some models this happens inside the same reply. On others it takes one extra step first. Neither changes what the assistant is allowed to do; see Reaching a tool.

What comes back without being paid for again

A provider charges much less for a part of a request it has just processed, and it matches from the front: the stretch at the start of this request that is byte for byte what the last one started with. Everything above is arranged to keep that stretch long.

On the model this release ships pointing at, a token the provider has already seen costs 10% of one it has not. That is the catalog’s own pair of rates, so it holds for anyone on that model.

What that came to, on one install. In the 14 days to 2026-09-20 the assistant was used on 10 of them, across every model that answered:

Over that window
requests measured	2,274
tokens sent	269,761,770
tokens the provider had already seen	247,625,182
that share	91.8%
requests that reused 99% or more	25.3%
what they cost	$10.38
what they would have cost with no reuse	$58.51

5.6 times less, and $48.13 not spent.

The largest requests do better than that share. 1,208 of them sent more than 100,000 tokens, which is where the money is. Half of those reused 98.6% or more, and 41.2% of them reused 99% or more.

Your own figure will differ, because it depends on how you work: turns close together reuse almost everything, and a conversation picked up the next morning starts cold. Yours is on the Conscience room’s Cache section, taken from the same ledger this was.

Only the sent half of a request is counted here, on both sides. What the model writes back is not repeated and no cache touches it, so including it would have added the same number to each and made the comparison look better than it is.

Three things decide how far it reaches.

• The first field, frozen for the life of the conversation.
• The second field, frozen the same way and for the same reason. Turning a tool on or off in Conscience reaches your next conversation, not the one in front of you.
• The conversation itself, which only ever grows at the end.

The runtime marks the last message whose bytes hold still and hands the provider that mark, so the parts that were always going to change sit outside the stretch being matched rather than in the middle of it. It also says which conversation this is, so two chats open on the same machine are never offered each other’s.

What ends it

• Time. What is stored lives for minutes of inactivity rather than hours, and nothing here asks for longer than whatever the provider gives by default. Coming back to yesterday’s conversation starts cold, and that first turn is charged in full.
• Wrapping up. A conversation that reaches its ceiling is cleared and carried on, so its first message changes and the provider sees one it has never met. See When a conversation gets long.
• A different model answering. What is stored belongs to one model, so a turn that falls through to the next model in the list is charged in full. See Models and roles.

Two things do not end it, and it is worth knowing which: editing one of the documents in the first field, and changing the working set. Both wait for your next conversation.

What you can change

• Which tools travel in full. Conscience, or config/working_set.yaml if you would rather do it in one pass.
• When a conversation gets wrapped up. Settings, under Chat.
• Nothing about the reuse. It is not a setting and there is nothing to tune. It works when the front of the request holds still, and holding it still is what the rest of this page describes.