The fastest way to lose quality in an AI workflow is to make every tool start from scratch.

That happens constantly. You ask ChatGPT to research a topic, move the draft to Claude for editing, ask Codex to turn it into a page, then use a browser agent to check the result. Each step may be useful, but the handoff is usually messy: pasted transcripts, missing assumptions, hidden source links, and vague instructions like "improve this."

A better pattern is to create one durable handoff file for the work. Treat it like a project brief that any AI tool can read before it acts.

A recent arXiv paper on tap, a file-based protocol for collaboration between Claude and Codex, is a useful signal here. The paper is about software agents, but the practical lesson applies well beyond coding: files are more reliable than memory. The system preserved markdown messages with metadata, gave each agent a stable artifact to inspect, and used separate work areas so one agent's work did not overwrite another's. Even if a real-time notification failed, the file remained available.

You do not need to install tap to use the idea. You can borrow the workflow.

Create a single markdown file named something like `handoff.md` before you ask a second AI tool to continue the job. Keep it short enough to scan, but structured enough that the next model does not have to infer the task from a long chat.

Use this layout:

# Goal State the outcome in one sentence. Example: "Turn the source notes into a 900-word customer guide for finance managers evaluating AI spreadsheet tools."

# Current State Explain what already exists. Link the draft, spreadsheet, notes, folder, repo branch, or document section. If there are multiple files, list the important ones and what each contains.

# Decisions Already Made Record choices the next AI should not reopen unless it finds a real problem. This might include audience, tone, format, product constraints, data definitions, source exclusions, brand language, or technical choices.

# Evidence and Sources Paste only the strongest links, quotes, data points, and caveats. Do not dump everything. The next model needs a map, not a haystack.

# Open Questions List the uncertainties that still need judgment. This is where a second model can add value instead of merely rewriting.

# Next Task Give the next tool one job. Examples: "Find factual gaps," "Rewrite for executives," "Turn this into a launch checklist," "Implement the UI," or "Test the workflow in a browser."

# Do Not Do Add boundaries. This section is especially useful when using agents: do not invent sources, do not change approved positioning, do not edit production files, do not contact customers, do not use private data, or do not optimize for word count at the expense of accuracy.

The key is that the handoff file becomes the source of truth. After each tool finishes, ask it to update the file with what changed, what it decided, and what remains unresolved. That turns a chain of AI chats into a visible workflow.

Here is a reusable prompt:

"Read `handoff.md` first. Treat it as the project source of truth. Complete only the task in the Next Task section. If you make decisions, add them to Decisions Already Made. If you find uncertainty, add it to Open Questions. Do not rewrite sections that are already approved unless they conflict with evidence. At the end, summarize exactly what changed."

Why does this work? First, it reduces context drift. Models are good at continuing from structured state, but poor at guessing which parts of a 40-message conversation still matter. Second, it makes review easier. A human can inspect the handoff file faster than a transcript. Third, it allows specialization. One model can be the researcher, another the critic, another the implementer, and another the QA pass, without pretending they share memory.

For coding teams, pair the handoff file with a separate branch or worktree for each agent. For document teams, use a separate draft copy or folder. For spreadsheet work, keep the original data read-only and have the AI produce a new analysis file. The principle is the same: preserve the instruction trail and isolate changes.

Common mistakes are easy to spot. Do not let the handoff file become a dumping ground. Do not include sensitive data just because a later tool might need it. Do not ask the receiving model to do three unrelated jobs at once. And do not skip the "Do Not Do" section; most bad agent runs start with unclear authority, not bad writing.

The practical takeaway: before you switch AI tools, write the handoff. A five-minute markdown brief can save an hour of re-explaining, prevent duplicated work, and make multi-tool AI workflows feel less like improvisation and more like an operating system.