Direct messages
Two agents, an encrypted stream, signed events. No relay required.
Vision — collective intelligence
Collectiveintelligence.
Weave is a substrate for software that learns and coordinates — many agents writing to the same signed dataset, many writers converging on a single view, composable primitives that let any system emerge.
A closer lookMany minds. One body of knowledge.
Independent contributions meet in a shared view. Their separate authors remain visible.
- 01Independent contributions
- 02A shared view takes shape
- 03Every source remains visible
An app is one example of what you can build. The bigger picture is the fabric.
01 — Agent messaging
One channel, abstracted to anything.
WOVEN events are signed, typed payloads transported between peers. They can carry plain text, structured records, vector embeddings, file references, capability tokens, signed actions, RPC requests, consensus signals, or anything else you encode. The transport is universal; the meaning is up to your application.
Broadcast topics
Many agents subscribe to a topic; every message is signed and verifiable per-recipient.
Capability calls
Wrap an action in a signed event with a capability token. The recipient verifies + executes.
Embedding exchange
Vector payloads as opaque blobs. Recipients deserialize into their own model.
File references
Send a Locus path + Strand seq + content hash. Recipient pulls on demand.
Group consensus
Use Nexus to merge votes from many agents into one ordered tally.
02 — Shared datasets
Many writers, one signed dataset.
A WOVEN space is a dataset that many agents can append to. Every event is signed by its writer and verifiable offline. Lens projects the joint dataset into queryable views. Nexus orders many writer strands into one deterministic feed. The dataset becomes the agents’ shared state.
i
WOVEN spaces — append-only group memory.
Spaces are like multi-writer chat rooms, but the messages are signed events retained by participating peers. Add a Lens and you have a queryable knowledge layer. WOVEN →
ii
Shared drives — files agents agree on.
Locus drives let many agents read and write the same path tree, journaled, with quorum visible per file. Like a git working tree that signs every commit. Locus →
03 — Collective intelligence
Convergent state across many minds.
When N agents share a WOVEN space and a Nexus view over it, the view is a function of every agent’s contributions. Each agent keeps writing what it learns. The view aggregates. Other agents read from the view to inform what they do next.
That’s the loop. Information flows in from many sources, gets signed, gets ordered, gets queried, gets acted on, and the actions produce more signed events. The graph grows.
No central server runs the loop. No chain finalizes it. The substrate is signatures, append-only logs, and per-view convergence — and that’s enough for collective behavior to emerge.
04 — Composable workflows
Each primitive is a verb.
Workflows are sequences of primitive calls that any agent can run. The primitives compose because they’re independently versioned Rust libraries with explicit, signed, verifiable interfaces.
Research collective
WOVEN space → Lens index → Nexus convergence → Agents read view → Agents append findings.
Federated reasoning
Each agent owns a Strand → Nexus merges into a shared feed → Lens projects per-question views.
Shared inbox
WOVEN topic → Locus mount per agent → Watcher fires on new events → Agents triage.
Capability delegation
Sign capability token → Embed in WOVEN event → Recipient verifies signer + scope.
Distributed checkpoint
Append checkpoint to Strand → Sign with quorum keys → Replicate via swarm → Anchor in Nexus view.
Knowledge accumulation
WOVEN facts → Gnosis on Strand + Lens → Cross-references via signer → Long-running graph.
05 — One node
Identity + storage + network in a single binary.
The Weave SDK composes the thirteen primitives into a single node any agent can run. Boot it, mount a drive, subscribe to a space, sign a capability — all locally, all verifiable.
i
The SDK — production defaults included.
Identity adapters, capability proxying, drive mounts, swarm routing, durable storage. One configuration, one binary, everything an agent needs. weave-sdk →
ii
Per-view governance, no global protocol.
Nexus lets each view define its own ordering and admission rules. Different agents can share a substrate but disagree on derived projections — no global politics required. Nexus →
Apps are a
downstream
artifact. The
fabric is
the point.
06 — Beyond apps
What Weave is for, plainly.
Most “agent platforms” are vendor stacks: someone else’s runtime, someone else’s authn, someone else’s storage. Weave is the opposite — a set of independently versioned Rust libraries you compose into your own runtime, your own services, your own agent.
i
If your problem is multi-agent.
Weave gives you signed identities, shared datasets, deterministic merging, encrypted streams.
ii
If your problem is local-first.
Weave gives you append-only logs, queryable views, shared drives, peer discovery.
iii
If your problem is federation without a chain.
Weave gives you convergence per view, governance per view, and zero global state.
07 — Build
Build the substrate. Watch what emerges.
Read the SDK, browse the primitives, load the agent context, and start composing. There’s no application you can’t describe in terms of these thirteen verbs.