The Transfer Envelope

I keep building the same thing without noticing.

It starts as a question about markdown versus HTML. When an agent hands me something — a page it captured, an answer it wrote, a file it edited — the thing I get back is flat. It reads fine. But I can't point into it. I can't say "that paragraph," "that element," "the line the agent actually changed." The structure was there when the information was created and it's gone by the time it reaches me. Every boundary the information crosses, it sheds a little more of what it was.

That sounds like a formatting complaint. It isn't. It's the same wound showing up in four places I'd been treating as unrelated.

In my capture system, it's literal: the moment I clip something from a page, the DOM — structured, addressable — gets flattened to plain text. The one element I actually selected survives, buried in a blob, un-pointable. In multi-agent work, it's the whole prompt-injection problem: instruction and data and memory get concatenated into one stream with no marker saying which is which. In my knowledge stores, it's five tables that can't reference each other because a link would mean a migration nobody wants to run. In anything I'd want to bill or audit, "which agent produced this, from what source" is a reconstruction instead of a query.

Four costumes. One problem. Information doesn't carry its own meaning across boundaries. It loses its type, its provenance, and its address — the three things that let a downstream actually use it instead of guessing.

The fix isn't a new markup and it isn't a new database. It's a discipline: make each unit of information carry a small envelope. What kind of thing it is. Who produced it, when, and whether to trust it. A portable address that survives the trip — including an address for its parts, not just the whole. And let the relationships between units be their own first-class records — typed edges that point at things without rewriting them — instead of columns welded into whichever store happened to hold them.

The word for the payoff is transport. A rename stops being a destructive migration and becomes a pointer you follow while keeping both ends. You can unify five fragmented stores without merging any of them. You can tell an agent "this came from an untrusted page, don't act on it" because trust is a field on the channel, not a vibe in the text. You can hand a captured element to a teammate on another machine and they can open exactly the thing you meant.

What surprised me is how little of this is new construction. Almost every part already exists somewhere in my system as a working spine with one leg missing. The storage layer already speaks in portable references; it just never grew addresses for sub-parts. The capture pipeline already builds a rich typed envelope at the browser; it just flattens it one hop later out of habit. The event log already stamps who-produced-what; it just never turned those stamps into walkable edges. The long-term solution was never "build the thing." It was: point all of it at one envelope and delete the six bespoke representations that grew up in its absence.

There's a version of this that's just my infrastructure. But I don't think the interesting part is path-dependent. The database, the wire format, the auth — those are mine, and someone else would rightly choose differently. What transfers is the shape: envelope, not payload. Address the parts. Relationships are their own layer. Trust is a channel you check at the point of action, not a string you sanitize. That's a pattern, not a product, and the pattern is the reusable thing. The running system is just proof it holds up.

This is the same throughline I keep hitting from other directions. Local problems need a trust layer, not another platform. Tests are agents with beliefs. Progressive autonomy is only safe when every action drags its provenance behind it. They're all the same move: don't build a bigger thing on top; make the information between the existing things carry its own meaning, so the pieces can finally talk.

I've been calling it the transfer envelope. It's the least glamorous idea I've had in a while, and I think it's under most of the others.

There's a machine-readable version of the shape now — a schema you can validate against, and the running system that proves it holds up: the contract.