The platform

White Tree is the memory.
Dúnedain is the harness.

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.

DÚNEDAIN
Claude
ChatGPT
Codex
Copilot
Gemini
Cursor
Slack
Jira
Salesforce
Workspace
Notion
Zendesk
White Tree
WHITE TREETHE ORGANIZATIONAL MEMORY
DÚNEDAIN
Claude
ChatGPT
Codex
Copilot
Gemini
Cursor
White Tree WHITE TREETHE ORGANIZATIONAL MEMORY
Slack
Jira
Salesforce
Workspace
Notion
Zendesk

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.

The runtime

Dúnedain is the runtime between agents and trajectories.

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.

Connects agents to White Tree

Every agent, whatever its model or vendor, reaches the memory through one harness. No bespoke integrations per agent, per team, per tool.

Assembles trajectory context

Builds the working context for a task from the trajectories the caller is authorised to inherit: the thread, not the corpus.

Exposes White Tree tools

Recall, search, lineage and write operations surface as native tools inside the agent's own environment, wherever it runs.

Enforces permissions

Authority, expiry and revocation are checked in the runtime path, on every operation, before anything moves.

Captures new decisions

As work happens, the reasoning behind it is extracted and linked into trajectories: a by-product of the work, never a chore.

Routes model calls

Calls to any model flow through the harness, so context, authority and receipts ride along with every request.

Manages writes

Every write to the memory is mediated: append-only, linked to what it revises, with the evidence for the change attached.

Triggers actions

When a trajectory calls for action in an external system, Dúnedain executes it under authority it can prove.

Presents trajectories to humans

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.

How it works

Capture. Link. Govern. Recall.

01 CAPTURE

During normal work

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.

02 LINK

Into trajectories

Evidence, decisions, actions, outcomes and corrections are linked into trajectories without rewriting history or inventing causation. What actually happened, in order, with sources.

03 GOVERN

With real controls

Every record carries provenance, permissions, expiry and revocation. Learning only moves where it is authorised to move, and every access leaves a verifiable receipt.

04 RECALL

To the next mind

The next authorised human or agent facing a related problem receives the thread: the judgement, not just the artefact. Onboarding in minutes, not months.

The unit of memory

Every piece of work becomes a trajectory.

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.

QuestionChurn spikes in Zendesk
EvidenceMarket scan in Claude
AlternativesThree options weighed
DecisionTiered pricing. Sarah + agent
ActionRollout shipped via Jira
OutcomeChurn down. Revenue up
RevisionThe playbook updates itself
The engine

A trajectory database, built for the agentic world.

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:

Trajectories as records

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.

Bitemporal core

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.

Append-only revisions

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.

Governed recall

Recall is a permission-checked primitive, not an application-layer afterthought. Provenance, authority, expiry and revocation are evaluated by the engine on every read.

Receipts from the engine

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.

Model-agnostic by design

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.

Governance is the product

A memory you can trust is a memory you can control.

A memory that leaks is worse than no memory at all. White Tree treats governance as a first-class capability, not a compliance checkbox.

Provenance

Every piece of learning knows where it came from: who said it, in which system, on what evidence. Nothing enters the memory untraceable.

Permissions

Learning flows only to authorised humans and agents. Role, team, project and sensitivity boundaries are enforced at recall time, every time.

Expiry

Some knowledge should die: pricing that lapsed, strategies that were superseded. Records carry expiry so the memory never serves stale judgement as current truth.

Revocation

Access granted can be ungranted: a departing contractor, a dissolved partnership, a changed classification. Revocation propagates instantly.

Bitemporal history

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.

Verifiable receipts

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.

SHARED STATE
MEMORY
PROVENANCE
GOVERNANCE
LEARNING

In practical terms: across every model, and every employee.

Token economics

Load the thread, not the corpus.

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.

↓0
tokens per week, falling as the company learns

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.

For people

Expertise that survives turnover

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.

For agents

Authority with an audit trail

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.

Next
The vision: the larger agent and the network
→