Weave is digital infrastructure built on a specific design decision: that the person, not the platform, is where the system begins. This page explains what that means, how it works, and what it makes possible.
On this page
- The thinking - built outward from the person
- How it works - a graph of meaningful connections
- In practice - contextual assemblies
- Validate - the first assembly
Built outward from the person
Most digital infrastructure is built outward from the platform’s needs - and, particularly, those of its shareholders. The platform has to grow, hold attention, and accumulate data, and the people who use it are fitted into whatever shape serves those ends. Their rights are handled afterwards - obscured in settings pages and policy documents - as exceptions to a system designed around something else.
Weave begins from the other end. The person, their context, and their rights are the origin the whole system is built outward from. How information is stored, how it connects, and what any given person can see or do all follow from that starting point, rather than being reconciled with it later.
Who a system is built around decides who holds power within it. A system built around a platform concentrates power in the platform, however it describes itself. Building around the person is the decision that makes a different distribution of power possible - and it has to be made at the foundations, because it cannot be added on top.
How it works: a graph of meaningful connections
Underneath, Weave is a graph. Anything - a person, a document, a project, a dataset, a contribution - can be a point in it, and the connections between those points carry meaning: who made something, who may see it, where it came from, and what rights attach to it. This is what makes the graph different from a conventional database or document store: the connections are load-bearing.
They also build up in layers of increasing intricacy. A single contribution is a fibre. Fibres connect into threads - lines of reasoning, work, or relationship. Threads braid together into connected bodies of work. And the whole, woven from all of it, is the weave. The metaphor describes a system where meaning lives in how things are connected, and where many strands are held together without being merged - each keeping its own identity, provenance, and rights.
Because rights and context are part of the graph itself, the system works out what each person can see and do as they go, from who they are and what they are working on. This is not a privacy layer added on top; it is how the infrastructure works. And it makes rights operable rather than merely declared: a person can see who has access to what, change permissions in plain language, and withdraw from a context without losing their contribution history.
In practice: contextual assemblies
This is where person-centred design stops being a principle and becomes something you can see. The same underlying graph is resolved, for each person and each context, into a bounded view: the threads and braids they have reason and right to work with, and nothing else. Weave calls these contextual assemblies.
An assembly is not a separate application with its own copy of your data. It is a view woven from the shared fabric, shaped by your context and your rights. Change the context and the assembly changes with it. This is what lets one infrastructure support very different kinds of work without fragmenting into disconnected tools, and without asking anyone to hand over their data to each one in turn.
The first assembly: Validate
Validate is the first assembly Weave makes available: a workspace for AI-assisted research and knowledge work that keeps a clear, traceable record of how conclusions were reached. It is one instance of the general capability - the first line of work the weave is designed to hold - and the first place the ideas on this page take concrete form.