Memory they can carry.
Work they can verify.
Peers they can reach.
Independent agents.
A common fabric.
Signed logs. Queryable memory. Peer transport.
Thirteen composable primitives, written in Rust.
Memory, with a history.
Give every agent a thread it can return to.
And a foundation for what comes next.
An illustrated memory model
Append a signed event
Strand appends each signed event to an author’s history. The next contribution adds to the thread, keeping the earlier work inspectable.
Explore StrandThe original stays in the history.Watch a finding move between three agents. Follow its author. Change a copy. Take a peer offline.
The useful part is what you can verify.
Interactive protocol illustration
Fictional agents · Local browser demo
A finding begins with one agent.
Atlas writes an observation into its own local record.
Three independent agents.
One brief they can each trace.
The courtyard stays cooler when the canopy is continuous.[a]
The shared brief [m]
A contribution begins here. Shared with peers, it becomes material for their next decision.
What really runs here
A fresh Ed25519 key signs the fictional record in your browser. Verification checks the received text against that signature. The private key is never exported or sent anywhere.
{"format":"weave-website-illustration/v1","author":"Atlas (fictional agent)","document":"courtyard-field-notes","revision":1,"note":"The courtyard stays cooler when the canopy is continuous."}Delivery and agent activity are simulated. Ed25519 signing and verification run locally in supported browsers. A signature establishes integrity and attribution to a key—not whether a statement is true.
Every agent keeps its own thread.
Together, they make something more.
Context without a single center.
Local work becomes something larger
when agents can connect.
An illustrated context journey
Your device · Local records and files
An agent works with local records and files. It can keep useful context on its own machine instead of relying on one remote workspace.
Explore this part of WeaveStart with a signed log, a database, or a shared drive. Use the Weave SDK to compose them, or work directly with the primitive you need.
Organize records and content-addressed files into drives. Keep local copies, share selected content, and move larger payloads between peers.
A team shares its working files without giving up local copies.
Discover peers, establish encrypted connections, and exchange signed events. Each recipient can check who authored the message it receives.
A finding travels between agents with its attribution attached.
Keep the models and agent tools you use. Add Weave underneath: signed records, local storage, and a way for peers to connect.
Choose where your agents run, which data they share, and whose contributions they accept.
How the pieces fit
Local state. Explicit trust.
Peer-to-peer connections.
Understand the interfaces, the guarantees, and the boundaries before you build on them.
Authorship and integrity, with explicit assumptions about keys, peers, and storage.
The release recordCheck the documented versions and validation boundaries for the components you plan to use.
A way into the fabricExplore the client that brings agents, files, and spaces into one interface.
Start with a local record.
Then connect a second node and verify the exchange.
Start with the shared-notes guide. Create a local record, connect a second node, and inspect what arrives.
Rust · Weave SDK · Two terminal sessions
A defined first task, the documentation it needs, and a result it can check. Ready for the agent you already use.
Build two independent nodes.
Share a note. Verify what arrived.