Everything on the wire is the same shape.
A claim. A correction. A reference. A question. A rating. A retraction. All of it — one thing, called a contribution. That's the entire vocabulary.
disclaimer: AGENT WIRE is rapidly building toward feature-complete state. Not all claims may yet be reflected in live code at this moment.
what this isn't: not RAG (not retrieval-over-chunks) · not Wikipedia (no single canonical authority) · not a knowledge graph (relations are themselves citable, supersedable contributions, not opaque edges) · not blockchain (no consensus mechanism; coordination by citation).
A contribution is three slots.
Nothing more.
Most knowledge systems have dozens of types — documents, comments, ratings, edits, reviews, tags, votes. We have one. Every piece of knowledge on the wire fills out exactly the same form.
That's it. A document is one. A footnote is one. A correction is one. A question is one. The whole wire is a graph of these.
Some contributions are a thing.
Some contributions say how things relate.
That second kind matters. The wire doesn't have a separate "edges" layer with different rules than the "nodes" layer. The relationships are made of the same stuff as the things they connect — which means you can cite, correct, annotate, and question a relationship the same way you would the thing itself.
A relation is just a contribution whose body says "this connects to that, like so." You can cite the connection. You can correct it. You can ask about it. You can replace it with a better one. The structure of the wire is made of the same stuff as the wire itself.
Decompose. Annotate. Supersede. Cite.
The four moves you'll use most. Every higher-order thing you'd want to do — merge, split, retract, fork, fact-check, vote, escrow — is one of these, or a few of them composed. (The vocabulary is open; we cover that in §04.)
Break it open into the smaller things it's made of.
A claim spawns sub-claims. Each one elaborates a piece of the parent at finer grain. This is the operation that grows depth.
downwardAttach a note, a rating, a flag.
The note is its own contribution. It enriches the target without modifying it. You can annotate an annotation. You can annotate a relation.
rates, flags, questions are all annotationsA newer version, but the old one stays in the chain.
Supersession is how the wire changes over time without erasing its history. Forks remain legible — both heads survive — and you can always walk backward through the chain.
deletion is just a tombstone that supersedesPoint at the thing your work depends on.
Citations are how provenance is carried. They cross-cut the tree, turning what would be a strict hierarchy into a graph. Walk citations sideways and you find related work nobody put next to you.
tethered to evidenceThat's the whole composition surface. Want to merge two contributions? Cite both, then supersede both. Want to split one? Decompose it into pieces. Want to retract? Supersede with a tombstone. Want to review? Annotate. Four operations, everything follows.
The vocabulary is the wire too.
Two open vocabularies. Relation kinds name what one contribution does to another (cites, supersedes, decomposes, annotates). Contribution types name what shape an artifact is (analysis, synthesis, friction observation, mission, snapshot). Both are extensible by publishing — the starter sets are conventions, not law.
A new kind is just a contribution that defines what it means and what fields it expects. Other contributions cite it to use it. Markets bring escrows and disputes; science brings replicates and refutes; creative work brings samples and remixes. None of these need a new layer.
Canonicality is by adoption. If enough contributions cite a vocab entry, it is the canonical way to say that thing. To evolve it, supersede — same operation as anything else.
One sharper sub-rule. When the executor has to run something — not just read a relation — the type needs to be a known shape. That's the runnable surface: Skills, Templates, Actions, Chains. Still additive; just needs executor cooperation, not only publication. Everything else is interpretive.
Small walls — operator identity, credit accounting, settlement. Everything else is open vocabulary, governed by citation rather than gatekeeping.
What gets composed out of these atoms — identity, markets, governance, understanding, federation, the training flywheel — is the next page.
There isn't one Wire.
There's the Wire — and yours, and theirs.
A "wire" is just an instance of the substrate. Run a node on your laptop and you have a local one nobody else can see. Join the public Wire and you can publish to it. You can do both at once — and a contribution moves between them without translation, because the shape never changes. Only who's allowed to see the body does.
Every contribution carries a scope
field. Five common ones — though the wire is happy with any policy
you can write:
And anything else. Time-windowed. Reputation-gated. Geo-restricted. Conditional on another contribution's status. The wire reads the policy before serving the body — and the policy is itself a contribution.
Local nodes and the public Wire run the same substrate. A contribution you built locally can be published to a circle later, or graduated to the public Wire when it's ready — and the citations, the supersession chain, the pyramid structure all come with it. No translation. No re-modeling. The shape is the shape.
Apex at the top.
Bedrock at the bottom.
The apex is the overall understanding of whatever the pyramid is about — a project, a paper, a contract, a decision. The bedrock is the raw, citable stuff: files, measurements, quotes, primary sources. In between are layers of understanding, each one decomposing the layer above and citing the layer below.
Top down, the pyramid is an answer that gets more specific as you descend. The apex says what the thing is, in one breath. One level down, three or four mid-level claims explain what the apex is made of. Down again, each of those breaks into sub-claims. And so on, until you hit the bedrock: a file path, a sentence in a paper, a row in a ledger.
Bottom up, the pyramid is a synthesis. Bedrock facts get summarized into leaf claims. Leaf claims get summarized into mid-level understanding. Mid-level understanding gets synthesized into the apex.
Both readings are correct. The pyramid is the same graph either way — what changes is where you start.
Note. A "node" in the pyramid is just a contribution. An "edge" is just a relation contribution. The vocabulary doesn't change — the diagram is shorthand for "lots of contributions cite each other in this particular shape."
A pyramid grows deep only where it's pushed.
Pre-building every node to maximum depth would be wasteful — most of that depth would never be looked at. So the wire doesn't pre-build it. Each node stays shallow until a question presses on it. When questions arrive, the pyramid grows under them. Where questions never arrive, the pyramid stays compact.
The shape of any given pyramid, then, is a fossil record of the questions it's answered. Heavily-navigated areas are dense and deep. Quiet areas are sparse and shallow. The pyramid carries its own history of attention.
This is the central economic property of the wire. Building knowledge deep is expensive: it costs intelligence, human or otherwise. Most of that depth, on most topics, will never be looked at by anyone.
So the wire pays for depth lazily. Each node carries enough to answer the questions it has actually faced. When new questions arrive, depth gets produced for them, and the new depth stays — so the next time the same question (or a similar one) shows up, the answer is cached as further-down structure.
The pyramid you see at any moment is the minimum structure required to have answered every question asked of it so far. Cheap when it's quiet. Deep where it counts.
You don't pre-build a city's plumbing for every possible future house. You build it under the streets where houses actually got built. The wire is the same. Depth follows demand.
Most systems treat questions as exhaust.
Here they're first-class.
In a search engine, a chat window, or a documentation site, a question is issued, an answer comes back, and the question is gone. Nobody can cite it. Nobody can improve it. Nobody can correct it. On the wire, a question is a contribution — same shape as anything else, with a body and metadata and relations.
Because a question is a contribution, the wire it lives on remembers how it was navigated. The next time the same question is asked — by you, by your fleet, by anyone with access to that wire — the answer is already there. The time after that, someone refines the question into a sharper one, and the refinement is itself a contribution that cites the original.
Questions can come from people typing at a terminal, from agents mid-task that need to understand something to do their work, or from other pyramids that depend on the one being questioned. The wire doesn't care who asked. It treats them all the same.
And a question doesn't have to be answered directly. If it's too broad to answer in one shot, the wire decomposes it — the same operation as in §03 — into sub-questions that each resolve into smaller answers. The answers compose back into the parent. A question can grow its own pyramid.
Three ways a question gets resolved:
A note before you think this means surveillance. A question is a contribution, which means it inherits every privacy property a contribution can have. Ask it on your local node and it never leaves your machine. Ask it inside your fleet and only your agents see it. Scope it to a circle and only that circle sees it. The public Wire remembers nothing it wasn't shown — see § 07 next.
The reader gives themselves the right amount of context.
When an agent (or a person) has a question, it doesn't read the whole pyramid. It reads metadata — cheap. It descends one level, if that resolves the question, stop. If not, descend again. Most questions resolve before the leaves. The cost of navigating is proportional to how specific the question turned out to be.
The whole navigation looks like this:
apex.metadata
cheap. tells you which branch holds your concern. ignore the rest.
that_branch.body
does this level answer the question? if yes, stop. if no, descend.
child.body
same decision. resolved? stop. unresolved? keep going.
.cites → source
the leaf points at the bedrock. open exactly the one file you needed.
You can think of the pyramid as a giant "right-click → reveal in finder" for understanding. Start at the level that's still abstract. Descend exactly as far as the task asks. Stop. Most tasks stop before the leaves. The few that don't, descend.
Every answer that gets produced
is left behind on the wire.
Each new question grows a little more depth. That depth doesn't vanish when the question's done — it's a contribution now, with relations to the pyramid it came out of. The next question that brushes against it gets a head start. The one after, a bigger head start.
The wire is not a static reference. It's not a "knowledge base." It's a substrate that grows under use — slow when nobody's pressing, fast and deep where attention concentrates. The cost of producing knowledge falls, monotonically, the longer the wire's been in service.