What Really Happens When You Send a Prompt to AI? From Tokens to the Final Answer

The letter you wrote

You type a sentence — maybe a paragraph — into the box and press send. From your side: an instruction. From the machine’s side: the start of a very long, very fast journey through a postal system that runs billions of times every minute. What follows is the trip your words take, from keystroke to the moment the answer appears. Same letters, same destination, every time. The only difference is what happens between the mailbox and the front door.

The mailbox

The journey begins at the interface — the app, the API, the website. Your request is received, checked, and pushed into a queue. From the outside this is invisible and instant; from the inside it’s the first gate. The mailbox doesn’t care what your letter says. It only cares that it’s stamped and addressed.

The sorting machine — tokenization

Now the letter is torn apart, carefully. The model doesn’t read words the way you do. It reads tokens — chunks of text, sometimes a whole word, sometimes part of one, sometimes a single character. Your prompt is chopped into a sequence of tokens, each tagged with a number from the machine’s address book. Why does this matter? Because tokens are the unit of everything that follows: the size of the envelope, the length of the journey, and the price of the trip.

The address book — the vocabulary

Each token maps to an entry in a fixed vocabulary the model learned. “Prompt,” “prompting,” and “prompt’s” are separate entries; an unfamiliar word gets split into pieces it knows. This is why spelling and spacing change behavior, and why the machine can work with languages it never saw in that exact order — it recognizes the pieces, not the whole.

The sorting center — context and attention

All your tokens — plus the system instructions, the conversation history, and the knowledge the model carries — are now laid out together. This is the context window, the largest envelope the system can handle in one trip. Then comes the cleverest part of the sorting center: attention. As the letter moves through the building, each token “looks at” every other token and judges how much it matters. Your key phrase gets a priority lane; a stray filler word is shuffled along quietly. This is where the model decides what your prompt is about — not by a rule, but by a weighted judgment across everything at once.

The route — the network

With the envelope sorted, the journey through the neural network begins. The letter passes through layer after layer, each a station that refines the understanding: pattern, then structure, then meaning, then intent. At every station the representation of your prompt is rewritten, slightly sharper than before. The model’s actual “knowledge” isn’t stored anywhere you can point to — it lives in the adjustments these stations have learned across the entire route. The journey is the knowledge.

The delivery truck — one token at a time

Here’s the part that surprises everyone: the model doesn’t compose a full answer in one step. It predicts the next token — one at a time, billions of times over the machine’s lifetime, but one token at a time for your letter. At each stop it scores the possible next pieces and picks one, with a small amount of controlled randomness (the “temperature”) deciding whether it takes the obvious route or a slightly more interesting one. The answer you read is a chain of single decisions, each dependent on everything before it — which is why the first words shape the last, and why an early misstep can echo to the end of the reply.

The recipient writes back

The token chain runs until the model hits a stop — the end of your question, a completion marker. The answer is assembled and sent back through the post: decoded from tokens into the words you read. It arrives in one piece, looking effortless, as if the whole letter had been answered in a breath. It wasn’t. Behind that breath: hundreds of layers, millions of learned adjustments, a context window sized by the envelope, and one token at a time.

Why the round trip matters to you

Once you know the route, several things stop being magic and start being plumbing:

• The envelope has a size. The context window is finite. Feed it more history and the earlier parts of your letter risk being squeezed out of the priority lane — which is why very long conversations slowly start to “forget.”
• Tokens are money. Pricing runs per token, input and output billed separately, and your prompt’s length is the envelope’s weight. A prompt twice as long isn’t twice as expensive in spirit — it is, in tokens.
• The model has no address book between trips. It doesn’t remember you between sessions, because memory isn’t in the model; it’s in the conversation you keep feeding it. That’s why “remember my style” only works while the context holds it.
• The randomness is a feature, not a bug. Same letter, second run, slightly different answer — that’s the delivery truck choosing a different road. When consistency matters, lower the temperature; don’t complain to the post office.
• The journey can run without you. Once you realize the whole route is a repeatable process, you can set it going in the background and collect the reply later — the machinery of the prompt is exactly what async agentic workflows put on autopilot.

The round trip, in one line

Your prompt is a letter. The model is a postal system that doesn’t read — it sorts, attends, and predicts — and the answer is a chain of single-token deliveries that look like a single thought. The trip is fast, cheap, and astonishingly good at pretending to be human. The next time you press send, picture the envelope: sorted, routed, and returned — one token at a time.

And one practical footnote before you go: the route is free to walk for a while before you buy a stamp — capable free options still exist — and knowing how the trip works is the difference between mailing letters blindly and mailing with intent.