The company brain is markdown — and agents maintain it

Most corporate knowledge dies in opaque tools. It scatters across a dozen apps, none of which an agent can read, and slowly rots into a graveyard of stale docs nobody trusts. Ours lives somewhere very different: a git-versioned vault where every piece of company knowledge is plain markdown — readable and writable by the same AI agents that ship our product, and reviewed with the same discipline as code.

A typed knowledge system, not a pile of notes

The scale is real — more than 7,660 versioned notes spanning strategy, research, patents, and product — but scale alone is just a bigger graveyard. What makes it a brain rather than a hoard is structure. At its center sits a typed knowledge system of nearly 1,900 pages, each one belonging to one of five classes: Concepts, Literature, Methods, Claims, and Entities. Those classes are not decoration; they define what a page is for and what it is allowed to assert, which is what lets both humans and agents navigate the corpus instead of drowning in it.

Every note also carries machine-readable frontmatter designed for an agent to read before it reads the note itself — an estimated token cost, a precedence level, a memory type, an intended audience, and a mandatory one-line English description. That header is small on purpose: an agent can scan it to decide what a page is, how much of its budget the page would cost, and how much weight it should carry, all without loading the body. The format is doing triage before a word of content is read.

Epistemic hygiene by template

Every page enforces good thinking by construction. It opens with a summary of fifty words or less, so an index scan is cheap and an agent can decide what to open without loading everything. It carries a confidence rating, so a hunch is not mistaken for a settled fact. It records its sources, so a claim can be traced rather than trusted on vibes. And — the part we are proudest of — every page must include a section that argues against itself: counter-arguments and data gaps, stated plainly. A knowledge base that only records what it believes is a liability. Ours is required to record what might be wrong.

Pages also declare how they relate to one another — what a claim supports, what it contradicts, what it depends on, and what it was derived from — so the corpus is a graph you can traverse rather than a flat pile of files. That is what lets a reader, human or agent, follow an assertion back to the evidence under it and outward to the conclusions that lean on it. A claim is never stranded; it sits in a web of what would have to be true for it to hold and what it would break if it fell.

The effect of these templates is cumulative. Because the shape is uniform, an agent reading the vault knows exactly where to find the confidence, the provenance, and the objections, and can weigh a page accordingly. Epistemic hygiene stops being a virtue people have to remember and becomes a property the format enforces.

This is also why the vault is not a museum piece off to the side of the real work. When an agent begins a task, its first move is to mine this corpus — reading prior decisions, related concepts, and the claims we already hold — before touching a line of code. The knowledge system is the memory the factory reasons from, so its coherence is not a nice-to-have; it directly shapes the quality of what gets built.

Agents are first-class citizens

The vault is not a read-only reference the agents consult; they help maintain it. New material that arrives is ingested under the same careful contracts as everything else — guarded so two processes do not clobber each other, logged so every change is auditable, and validated against the schema so a malformed page cannot slip in. Loose notes get filed where they belong, dry-run-first, with the proposed changes written out for review before anything moves. The agents that build the product also tend the memory of the company, under the same guardrails.

Knowledge QA runs as lint

The most useful idea here is treating knowledge like code and running quality checks on it. A linter for a codebase flags dead code and broken imports; ours flags orphan pages nobody links to, dead ends, stale low-confidence claims, missing provenance, and — most valuable of all — pages that contradict each other. Contradiction detection across a corpus is exactly the kind of slow, thankless review a human rarely gets around to, and exactly the kind of thing that quietly corrodes an organization's understanding of itself. Running it as lint, with dated reports logged back into the vault, turns 'is our knowledge still coherent?' into a check you can run rather than a worry you carry.

Same version control, same contracts

Put the pieces together and a pattern emerges that we think is the real meaning of 'AI-native'. Code and corporate memory live under the same version control, move through the same agent contracts, and answer to the same fail-closed philosophy. Nothing important is trapped in a tool an agent cannot open, and nothing an agent writes escapes the review that keeps the rest of the factory honest. The company's understanding of the world is not a set of documents; it is a maintained system — and it is maintained by the same hands that build the product.