What is Dossier?

Dossier gives every organization a sovereign, compounding learning loop — its institutional memory, owned and portable, that humans curate and agents extend. It runs directly, or through the agencies that already serve a client.

Every organization is now told it needs a “company brain.” Almost none can build one — it’s a multi-year internal program. Dossier turns that program into a days-long install. We don’t sell a model. We install the loop: your knowledge, captured as plain files in your own git, queryable by agents, getting smarter every time someone curates it.

The loop, end to end

A single pass turns messy source material into owned, queryable institutional memory — and one full pass is one diff in the client’s own git history:

  Raw knowledge          Clean markdown        OKF graph             Explainable
  files · sites · docs ──▶ + provenance ──────▶ (your git repo) ────▶ GraphRAG (MCP) ──▶ agents
       ▲   INGEST              EXTRACT              SERVE                  query
       │
       └────────── humans curate · agents extend · it compounds ──────────┘

Ingest — raw client knowledge (files, sites, docs) becomes clean markdown with provenance stamped on every fragment.
Extract — that markdown becomes atomic OKF atoms with typed edges between them: one concept per file, each one sourced and confidence-scored.
Serve — the atoms are served over explainable GraphRAG, via the Model Context Protocol (MCP), so any agent can query them.
Curate & extend — humans curate; agents extend; every approved change compounds back into git.

The OKF repo is the system of record; the vector and graph indexes built over it are replaceable caches — delete them and lose nothing. That inversion is the whole point: most knowledge tools make the index the product and your data the export. Dossier makes your git repo the product and the index the cache.

The artifact: one atom, one file

Every concept Dossier learns is a single file — typed, sourced, confidence-scored, cat-able, git clone-able. No database, no SDK to read it:

---
type: decision
id: 0007-produces-edge-direction
title: The produces edge is canonical on the producing process only
status: active
confidence: verified
owner: knowledge-architect
decided_on: 2026-06-14
relates_to: [knowledge-model, 0003-knowledge-model-v0]
---

# DEC-0007 — `produces` edge direction (single source of truth)

The `produces` edge is declared once, on the process that creates the artifact —
the single source of truth. A capability links its signature artifact via
`relates_to`, never `produces`.

This format is OKF — the Open Knowledge Format, plain Markdown + YAML in git. Because it’s just files, your knowledge survives every tool, every vendor, and every model swap. The “company veteran” you encode this year is still readable in ten.

The three faces of one loop

The Brain, the Agency, and the Ladder are the same learning loop seen three ways — one-to-one with the mission’s “institutional memory that humans curate and agents extend.” All three sit over the one OKF Company Brain in the client’s git repo: the Brain fills it, the Agency acts on it, the Ladder reads it — and both the Agency and the Ladder compound back into it.

Brain — what the org knows

The institutional memory: ingest → extract → OKF → serve over explainable GraphRAG. This is most of what you just read, and it runs offline, end to end, today.

Agency — what the org does

The act-and-learn loop: an agentic board of task atoms, drained by persona-grounded bounded sessions that propose work, carried to review for a human to approve — which compounds it into git. The runtime core is field-proven; the dashboard surface and scale are forward work.

Ladder — how a human adopts

The adoption wedge: a deterministic 4-axis scorer (value · risk · readiness · momentum) over a client’s process/workflow atoms → a Now/Next/Later roadmap, emitted as a sovereign OKF artifact. Built and verified on a real tenant.

The moat is act-and-learn, not act-and-forget: competitors build single-function agent teams on thin context that forget. Dossier’s agents act on the org’s whole owned memory, and every approved action compounds back into git. The human stays the gate — agent work stops at review; only a human disposes.

Why your knowledge should outlive every model swap

“Our priority has to be building a frontier ecosystem, not just a frontier model … one where every organization can own the learning loop that encodes its institutional knowledge, compounding its human and token capital.”

— Satya Nadella, A frontier without an ecosystem is not stable, 2026

Nadella named the what and the why. Dossier is the how and the who.

Productized, not bespoke. A multi-year internal program, turned into a days-long install. We don’t sell a model — we install the loop.
Sovereign by open standard. Built on OKF in the client’s own git — never locked to us, to any vendor, or to any model. Your knowledge, your repo, forever.
Agent-native from atom zero. The loop is built by agents and for agents, while humans curate — using Claude’s own primitives as the engine. Dossier is itself a learning loop that builds learning loops.

Run it directly, or through an agency

Any organization can adopt Dossier directly and stand up its own loop. Agencies are the highest-leverage channel, not a gate: a Digital Experience Agency already has the clients, the trust, and the access, so Dossier makes it the general contractor that installs each client’s sovereign loop. Both paths are first-class, and both ship as one Claude Code plugin.

Nothing here is a mockup

The claims on this page are demonstrable on Dossier’s own dogfood knowledge base — Dossier runs its own learning loop on its own repo. The same surfaces that serve a client serve us:

The knowledge base — Dossier’s own OKF graph, rendered.
DEC-0052 — the “one loop, three faces” decision, in full.
The board — the live task atoms the Agency drains.
The graph — the typed-edge knowledge graph, navigable.