Coordinating via files and artifacts

In multi-agent systems, not all coordination needs to happen through messages or shared memory. Files and other durable artifacts give agents a simple, persistent way to collaborate without being active at the same time. This matters when agents run independently, restart, or need to hand work off in a way that survives process boundaries.

Using files as a communication medium

A file can act as a neutral meeting point between agents. One agent writes information to disk, and another agent reads it later. This approach works even when agents are not running concurrently or do not know about each other directly.

Files are especially useful when coordination needs to persist beyond a single execution or when agents are loosely coupled.

Writing artifacts that other agents can consume

An artifact is a file written with the expectation that another agent will read it. The content should be structured and predictable so that consuming agents can process it reliably.

For example, an agent generating a static website might write an HTML fragment describing a planet.

html = "<h1>Mars</h1><p>The red planet.</p>"

with open("mars.html", "w") as file:
    file.write(html)

The intent here is not presentation, but handoff. Another agent can treat this file as an input rather than a final product.

Reading artifacts produced by other agents

Consuming agents read artifacts created elsewhere and use them as inputs to their own logic. The reading agent does not need to know how the file was created, only how to interpret its contents.

with open("mars.html", "r") as file:
    page_content = file.read()

Once loaded, the data can be combined with other inputs, embedded into larger outputs, or used to make decisions.

Managing artifact lifetimes and ownership

When multiple agents write files, it becomes important to know who owns an artifact and how long it should exist. Some files are temporary signals, while others represent durable results.

Clear conventions help. An agent might write to a specific output directory, or include timestamps or identifiers in filenames to avoid collisions.

Coordinating agents through durable shared outputs

Durable artifacts allow coordination without tight synchronization. One agent can produce output, exit, and another agent can pick up where it left off later. This makes the system more resilient to restarts and partial failures.

By treating files as shared outputs rather than internal details, agents remain independent while still working toward a common goal.

Conclusion

By coordinating through files and artifacts, agents gain a durable, low-friction way to collaborate across time and execution boundaries. We now have a clear mental model for how shared outputs can replace direct communication, making multi-agent systems simpler and more robust.