Skip to content

What happens in three seconds: the path your prompt takes

When you click Send in an AI tool, three things happen in roughly that order: the text leaves your computer, the model produces a reply, and the reply comes back. The whole round trip usually lands in two to four seconds for a short message. The shape of the trip is the same for everyone; only the time scales with how long the message is.

This lesson slows that round trip down. Three seconds passes too quickly to think about, and what passes too quickly to think about gets treated as if it does not happen at all. The lesson walks the seven steps the message takes from your keyboard to the model and back, names the canonical vocabulary one vendor uses to talk about it in their privacy policy, and introduces the difference between what is structurally possible at each step and what the vendor has committed to doing.

The point of the mental picture is not anxiety. The point is that you can apply it before any future paste, on any AI tool, on any day.

You, if you have read the first two lessons and now want to understand the actual mechanics of what happens when you use an AI tool. The lesson uses the same teacher-named-Aisha example as the previous ones: she has the starting paragraph from the second lesson, the sticky note that says check what’s in the tab before you paste, and she is at her desk on Friday morning about to use the new tool for the first time. She wants to know where her message actually goes before she clicks Send.

The technical content of this lesson (CDN, model service, plaintext, streaming) is denser than the first two lessons. The lesson introduces each technical term when you would naturally encounter it, not abstractly, so the difficulty does not jump on you.

By the end of this lesson you will be able to:

  • Name the seven steps of a round trip in your own words: keys to chat box, browser onto the network, the CDN (front door), inside the model service, the model thinks, the reply comes back, the reply appears
  • Recognize the CDN (Content Delivery Network) as the first piece of vendor infrastructure your message touches, and tell what metadata it sees (timestamp, region, message size) versus what could be observed if the vendor chose to log it
  • Define plaintext as the state of a message inside the model service and explain why end-to-end encryption (the kind messaging apps like Signal use) does not apply to AI tools the same way
  • Recognize Inputs and Outputs as the words one major vendor uses in their privacy policy for messages and replies, and know that other vendors use different vocabulary for the same two things
  • Tell the difference between the path (what is structurally possible at each step) and the policy (what the vendor has committed to doing about it), and read either layer without confusing it for the other

These are things you can do, not just things to know. The goal is that the next time you read a vendor’s privacy policy you have a mental picture of what the words on the page are talking about, so the policy becomes readable.

The lesson reads in about 14 minutes. The applied exercise that follows it (walking one low-stakes message through all seven steps) takes another 10 to 15 minutes.

This is the first lesson in the second part of the Privacy and Local-First AI track. After this lesson, the next two lessons walk the same path again from different angles: who can see what at each step, and what persists after your conversation ends.

After that, the rest of the track turns the mental picture into action: categorizing the threats that exist along the path, reading a vendor’s actual policy commitments against the path, understanding architectural alternatives, and building your own personal privacy plan.

These terms are defined in the lesson body. If you encounter them in other AI privacy material, this lesson is where you’ll meet them first.

  • Round trip: the full journey of a single message-and-reply pair through the chain of systems.
  • CDN (Content Delivery Network): the vendor’s geographically distributed front-door infrastructure. The first place inside the vendor’s systems where messages are decrypted and inspected; what gets logged versus what passes through is a vendor policy choice.
  • Request metadata: the wrapper around the message contents: timestamp, region, message size, sometimes browser type.
  • Model service: the vendor software that runs the model. Receives the message, hands it to the model, watches the reply being generated, sends the reply back out.
  • Plaintext: the opposite of encrypted; readable text. Messages are plaintext inside the model service even when they were encrypted in transit.
  • Streaming: sending the reply back one piece at a time as the model generates it; the reason replies often appear word by word in the chat box.
  • Inputs and Outputs: the vocabulary one major vendor uses in their privacy policy for the user’s messages and the model’s replies. Other vendors use different words (prompts and responses, requests and outputs, content) for the same two things.
  • API (Application Programming Interface): the direct connection a vendor offers to developers and apps, where one piece of software talks to another without going through the vendor’s chatbot website.
  • Context window: the model’s working memory for a single conversation. Named here for orientation; covered in depth in the third lesson of this section.

This lesson draws on:

  • Clawless knowledge base chapter “What is Under the Hood” (Creative Commons Attribution-ShareAlike). The contrast case in this lesson (where a desktop AI app talks directly to the AI provider with no intermediate vendor server holding chat logs) comes from this chapter.
  • One major AI vendor’s public privacy policy (URL on the References tab). Quoted directly for the Inputs and Outputs vocabulary definition. The same vendor’s policy is one of the worked examples in the fourth lesson section of this track.

Full annotated source list and notes on each source’s strengths and limits are on the References tab.