A developer introduces Proofpress, a prototype that embeds a portable revision/decision trail into Markdown and static HTML artifacts so agent-to-agent handoffs preserve context, with sidecar integrity evidence for DOCX.
I’ve been thinking about what actually survives an agent-to-agent handoff. Suppose one agent drafts a proposal, another reviews it, and a third later implements it. The artifact may move cleanly between them, but the decisions behind it often live somewhere else - in MEMORY.md, session logs, a local vault, or the orchestrator’s state. That works when every agent shares the same memory system and the handoff protocol passes the right context. But agent handoffs are not always that controlled. The file may be written to a repository, attached to a task, uploaded to object storage, sent to another organization, or reopened by a different agent weeks later. At that point, the receiving agent may see the final document without knowing: which revision was accepted; what materially changed; why that change was accepted; which alternative was explicitly rejected; who or what recorded the decision. An agent-to-agent handoff message can include this context. But that context belongs to one transfer. If the artifact moves again through another channel, the handoff message may no longer be present or discoverable. So the question is whether a small part of the decision trail should travel with the artifact itself. Not the full conversation or private workspace memory (that would be inappropriate) - only the decisions admitted into the shared artifact: accepted transitions, stated reasons, consequential rejections, and attribution. I built a prototype called Proofpress around this idea. For Markdown and static HTML, the artifact can carry a portable revision record. A receiving agent can inspect it and deterministically check whether the recorded change claims match the artifact’s actual diff. For DOCX, the current model is more conservative: a separate sidecar carries semantic integrity evidence. It can detect canonical-content drift, but it is not embedded revision history. This is not intended to replace agent memory or orchestration. If all agents reliably share the same vault, that may already solve the immediate handoff. The narrower question is what happens when the artifact leaves that trust and retrieval boundary - or simply outlives it. There is also an architectural resemblance to C2PA: provenance remains bound to an asset instead of depending entirely on the system that created it. Proofpress is not C2PA-compatible, though, and currently has no equivalent signing or authenticated identity model. The distinction I’m testing is: A handoff message explains this transfer. Artifact provenance survives the next one. Does that distinction seem useful in real multi-agent workflows? Or should this context remain entirely in the orchestration layer, Git, a central ledger, or an external knowledge system? I’ll put the implementation and real CLI output in a comment below. Blunt criticism welcome.
An exploration of emerging Markdown-based file formats (AGENTS.md, SKILL.md, spec/plan/task files, memory files) that form a 'metacode layer' enabling coding agents to discover and apply project knowledge directly from repositories, shifting how intent is translated into implementation.
The author reflects on the limitations of using flat markdown files for long-term agent memory, which leads to prompt debt as the memory grows, and advocates for graph-based memory representations that retrieve relevant context dynamically.
Adaptive Markdown is an open-source document format/viewer that uses coding agents to make documents interactive, enabling live workspaces for tasks like academic reading, note-taking, and automated workflows.