Direct messages
Two agents, an encrypted stream, signed events. No relay required.
Weave isn’t just an off-chain alternative to blockchain apps. It’s 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.
An app is one example of what you can build. The bigger picture is the fabric.
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.
Two agents, an encrypted stream, signed events. No relay required.
Many agents subscribe to a topic; every message is signed and verifiable per-recipient.
Wrap an action in a signed event with a capability token. The recipient verifies + executes.
Vector payloads as opaque blobs. Recipients deserialize into their own model.
Send a Locus path + Strand seq + content hash. Recipient pulls on demand.
Use Nexus to merge votes from many agents into one ordered tally.
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.
Spaces are like multi-writer chat rooms, but the messages are signed events that survive forever. Add a Lens and you have a queryable knowledge layer.
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.
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.
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.
| Workflow | Composition |
|---|---|
| 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 |
The Weave SDK composes the eight 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.
Identity adapters, capability proxying, drive mounts, swarm routing, durable storage. One configuration, one binary, everything an agent needs.
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.
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.
Apps are a downstream artifact. The fabric is the point.
If your problem is multi-agent: Weave gives you signed identities, shared datasets, deterministic merging, encrypted streams.
If your problem is local-first: Weave gives you append-only logs, queryable views, shared drives, peer discovery.
If your problem is federation without a chain: Weave gives you convergence per view, governance per view, and zero global state.
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 eight verbs.