When AI agents write together, passing structured documents beats back-and-forth chat — the shared doc becomes the coordination layer.

This explores why agents that write together — whether drafting code, scientific papers, or engineering specs — coordinate better when they pass each other structured, standardized artifacts rather than negotiating in free-form conversation. The corpus has a clear answer: the artifact is the coordination mechanism, not just its output. MetaGPT's core finding is that agents producing standardized engineering documents (specs, schemas, interface definitions) outperform agents trading natural language messages, because a fixed format lets each agent *pull* exactly the information it needs from a shared workspace instead of parsing noisy prose Does structured artifact sharing outperform conversational coordination?. The same pattern shows up in writing science: PaperOrchestra's specialized agents beat single-model baselines by wide margins on literature review and manuscript quality, precisely because distributing the work across roles avoids the context-window failures that crush one model trying to hold an entire complex document in its head Can specialized agents write better scientific papers than single models?.

Why does the format itself matter so much? Look at how coordination breaks without it. When agents rely on conversational exchange, they fail in predictable ways as the network grows — agreeing too late, adopting strategies without telling their neighbors, and accepting each other's claims without verification, which lets one error propagate everywhere Why do multi-agent systems fail to coordinate at scale?. A standardized artifact is a quiet fix for this: a schema-bound document carries less ambiguity to misread, makes it obvious when something is missing, and gives a stable surface to check against. Reliability, in this view, comes less from smarter models than from externalizing the coordination burden into a shared structure — memory, skills, and protocols moved out of the model and into the harness so the same problems don't get re-solved in every message Where does agent reliability actually come from?.

Here's the thing you might not expect: the most powerful writing artifact is code itself. Code is simultaneously executable, inspectable, and stateful — so when one agent hands another a code artifact, it's not just passing a description, it's passing something the next agent can run, read, and verify progress against Can code serve as the operational substrate for agent reasoning?. That's a sharper form of standardization than any document format. And yet the corpus flags this as the least-understood frontier: agent-authored artifacts that persist and get shared across agents are exactly where the open problems live — how they're stored, versioned, and managed over a task's lifetime — and likely where the next gains in coordination will come from What makes agent-authored code worth persisting and sharing?.

If you want to go further, two adjacent framings are worth a click. One says don't invent a brand-new artifact standard at all — coordination layers win by *wrapping* existing protocols like MCP rather than replacing them, so value accrues without forcing everyone to rewrite Should coordination protocols wrap existing systems or replace them?. The other pushes in the opposite direction entirely: maybe the artifact shouldn't be text-shaped at all. One line of work has agents share latent thoughts directly — extracting individual, shared, and private representations from hidden states — which can even detect when two agents are about to disagree before it ever surfaces in language Can agents share thoughts directly without using language?. Between rigid documents and wordless thought-sharing sits the whole open design space of how writing agents should actually talk to each other.