Dúnedain works alongside every human, agent and system during normal work, and carries what it gathers into White Tree: a governed, customer-controlled organisational memory.



















WHITE TREETHE ORGANIZATIONAL MEMORY






Every model on the left, every system of record on the right, every person in between. Dúnedain is the connection layer that observes work as it happens; White Tree is where the resulting judgement lives, governed and permanent. A decision made anywhere is known everywhere.
Agents never touch storage. They run inside the harness, and the harness performs every operation on the memory on their behalf: nine jobs, all in the runtime path, all under authority.
Every agent, whatever its model or vendor, reaches the memory through one harness. No bespoke integrations per agent, per team, per tool.
Builds the working context for a task from the trajectories the caller is authorised to inherit: the thread, not the corpus.
Recall, search, lineage and write operations surface as native tools inside the agent's own environment, wherever it runs.
Authority, expiry and revocation are checked in the runtime path, on every operation, before anything moves.
As work happens, the reasoning behind it is extracted and linked into trajectories: a by-product of the work, never a chore.
Calls to any model flow through the harness, so context, authority and receipts ride along with every request.
Every write to the memory is mediated: append-only, linked to what it revises, with the evidence for the change attached.
When a trajectory calls for action in an external system, Dúnedain executes it under authority it can prove.
The same memory agents run on is readable by people: the thread, the evidence and the call, in plain sight.
And because the trajectory model is logical, not physical, the memory agents see is the same whether the memory runs in our cloud, your VPC or a fully sovereign deployment. Storage can move; the shape of the company's judgement does not.
No forms, no "knowledge management" chores. Dúnedain sits in the tools your people and agents already use and records the decision trail as a by-product of doing the work.
Evidence, decisions, actions, outcomes and corrections are linked into trajectories without rewriting history or inventing causation. What actually happened, in order, with sources.
Every record carries provenance, permissions, expiry and revocation. Learning only moves where it is authorised to move, and every access leaves a verifiable receipt.
The next authorised human or agent facing a related problem receives the thread: the judgement, not just the artefact. Onboarding in minutes, not months.
Artefacts tell you what was written. Trajectories tell you what happened: the question that started it, the evidence gathered, the alternatives that lost, the call that was made, what it caused, and how the playbook changed when the world answered back. That is the difference between storing your company's output and storing its judgement.
White Tree is not a retool of what already exists. It is not Postgres with a vector column bolted on, not Pinecone with metadata, not Neo4j with new labels, and not an index over an Elasticsearch cluster. Those systems answer the question they were designed for: what is stored? A trajectory database answers a different question: what happened, who learned it, and who may inherit it?
You cannot retrofit that question onto artefact-shaped storage. A row does not know which alternative lost. A vector does not know it was superseded last Tuesday. A graph edge does not know who authorised it, or that its authority expires on Friday. So we made the things an organizational memory needs into the engine's native primitives:
The unit of storage is the trajectory: question, evidence, alternatives, decision, action, outcome, revision, causally linked. Not rows, not chunks, not embeddings. Structure survives storage.
Every fact carries two clocks natively: when it was true in the world, and when the company believed it. "What did we know when we decided?" is a query, not a forensic project.
Writes add; nothing overwrites. A correction links to what it corrects, with the evidence for the change. History cannot be silently rewritten, by anyone, including us.
Recall is a permission-checked primitive, not an application-layer afterthought. Provenance, authority, expiry and revocation are evaluated by the engine on every read.
Every read and write emits a verifiable receipt at the storage layer. An audit is a lookup. You do not have to trust the application code, because the engine cannot forget to log.
Trajectories live below the model layer. Claude today, whatever wins next year: the memory is untouched by model churn, and never becomes anyone's training data.
General-purpose databases were built for software that sits still and humans who query politely. This engine is built for thousands of agents reading and writing judgement concurrently, under authority, with receipts. That is the workload of the agentic enterprise, and nothing on the shelf was designed for it.
A memory that leaks is worse than no memory at all. White Tree treats governance as a first-class capability, not a compliance checkbox.
Every piece of learning knows where it came from: who said it, in which system, on what evidence. Nothing enters the memory untraceable.
Learning flows only to authorised humans and agents. Role, team, project and sensitivity boundaries are enforced at recall time, every time.
Some knowledge should die: pricing that lapsed, strategies that were superseded. Records carry expiry so the memory never serves stale judgement as current truth.
Access granted can be ungranted: a departing contractor, a dissolved partnership, a changed classification. Revocation propagates instantly.
The record keeps both what was true and what we believed at the time. You can ask "what did we know when we decided?" and get an honest answer.
Every access, every recall, every flow of learning produces a receipt that can be audited and proven. Trust is built on evidence, not policy documents.
In practical terms: across every model, and every employee.
Retrieval-based systems pay to reprocess the archive on every question. White Tree recalls the relevant trajectory and starts from what the company already concluded. The work gets cheaper as the organisation gets smarter, and the advantage compounds.
And because trajectories live outside any single model, the memory survives model churn: swap Claude for the next frontier model and the company's judgement comes along untouched.
A new hire inherits the judgement of everyone who came before: why the architecture is shaped this way, which customers churn and why, what was tried in 2024 and what it cost. The apprenticeship that used to take years arrives on day one, with provenance attached.
Agents act with the company's accumulated judgement instead of a cold context window, and every action they take is recorded with who authorised it and on what basis. The more agents you run, the more the memory earns.