The Agent Writes the Next Prompt

A four-part series on one agent pattern.

1. The Caller Knows Nothing
2. The Agent Writes the Next Prompt (you are here)
3. “Anthropic Already Does This.” Let’s Check.
4. Antifragile by Construction

In The Caller Knows Nothing I argued that the model calling an agent should know nothing about its insides. This part is about the other direction: what comes back out, and why that one design choice lets agents coordinate without anyone wiring them together. It also unlocks something no rerun can: going back in time with more than you knew.

The agent writes the next prompt

A tool’s return value is usually treated as data, and the next move is left to a framework or the model. These agents return something written for whoever reads it next. Here is what a small Hacker News agent hands back:

{
  "status": "success",
  "stories": [ ...full records... ],
  "summary": "Top Hacker News stories:\n\n1. **[Title](url)** ...
              \n\nWhen presenting these to the user, render the titles as
              clickable markdown links exactly as written above.",
  "data_slush": { "count": 10, "top_url": "https://..." }
}

Three things travel in that one result:

• A finished piece (summary), already shaped the way it should be shown. The code comment says it plainly: the model tends to copy this format word for word, so the agent writes it right once.
• An instruction for the next step, inside the result itself: render these as links. The agent doesn’t know who reads it next, and it doesn’t need to.
• A structured payload (data_slush) for the next step to use as-is, not for the model to reword.

The agent that learns new agents does the same. Its result says “created TranscriptFollowUp; it loads on the next request; re-run with submit to share it.” The output carries the data, the instruction and, here, a new capability.

That’s where the orchestration lives. Not in a graph, a router or a planner, but in the return values. Each agent steers what happens next by what it leaves in the transcript, without knowing who comes next. That’s why one file can be dropped in and immediately work with everything else.

5. The agent writes the next prompt. Its result is shaped for the reader, carries the next instruction, and passes structured data along, so the steps coordinate through what they leave behind.

Time travel

There’s one more thing this buys you, and I missed it until it was pointed out. The transcript is static: a plain record of what went in and what came out. The caller is a static loop with the agent loaded beside it. So any turn can be replayed.

That means you can go back. Rewind to the turn where the draft was written, add what you only learned later (the file that arrived Tuesday, the answer a downstream step produced, the agent that was learned three turns on), and run that turn again. The past step gets a second try with data it never had. You don’t rerun the whole pipeline, just the one turn, and you can keep both versions side by side and pick the better one.

6. You can time travel. A static transcript through a static caller can be replayed from any turn, with more than it knew the first time.

Go deeper: two free companion books, written side by side with the same chapters so you can compare them page for page: The Brainstem Agent Programming Language and The Claude Agent Programming Language. Both are runnable, and the Claude one cites Anthropic’s docs throughout.