Tatara
Product

The governed document: one source, two audiences

A governed document is clean enough for a person to read and structured enough for any model to use. How we shape one document to serve both.

One document read by a person and by a chat window.

Most knowledge lives in one of two failure modes. Either it's written for people (a tidy page that reads well and tells a machine almost nothing) or it's written for machines (a wall of fields a person would never sit down to read). Pick one and you lose the other.

A governed document refuses that trade. It's one artifact for both audiences: prose a person wants to read, on top of structure a machine can act on without guessing.

What is a governed document?

A governed document is an ordinary Markdown document that can't exist without a declared shape. In Tatara, an agent writing one must supply six things: a type, a folder, a title, a one-sentence description, the body itself, and one to five tags drawn from the brain's registry. A write missing any of them is rejected before anything is stored.

That's the whole idea, and the constraint is deliberate. A document that has to say what it is can be found by something other than you. One that doesn't becomes a file somebody eventually greps for and fails to find.

Why not keep a human version and a machine version?

Separate human and machine versions don't work because the moment there are two, one of them is wrong and you can't tell which. When a teammate opens a document about your pricing, they should see clear sentences and a sensible shape. When an agent reads the same document, it should find the same facts in a form it can rely on. Nothing needs keeping in sync, because there is no second copy.

Once knowledge splits into a human version and a machine version, one of them starts to drift. So don't split it.

Everything else depends on that single source. You can trust what an agent tells you about your company because it's reading the exact text your team wrote, not a stale copy or a paraphrase.

What's in one?

A governed document has five declared fields and a body, and each one exists because some reader, human or machine, needs it.

PartWhat it isWho it's for
BodyPlain Markdown prose. Headings, lists, tables, links.The person reading it, and the model reading it
TitleWhat the document is called.Both
DescriptionOne sentence saying what this document is.Retrieval. It shows up in listings so an agent can decide whether to fetch the full text
TypeFree-form classification (policy, playbook, meeting-note).Filtering, and telling an agent what kind of thing it's looking at
FolderThe document's place in the tree.People browsing; agents scoping a search to one area
TagsOne to five, from a three-tier registry: area, topic, goal.Cross-cutting retrieval that folders can't express

Only the body is prose. The other five take a handful of words each. That's the trade: about thirty seconds of declaring per document buys retrieval that works without anyone reading the corpus.

The description does more work than it looks like. When an agent lists a folder, it gets back lightweight rows (id, path, title, type, updated date, description) rather than content. A good description often answers "is this the document I want?" outright, so the agent never fetches the body at all. A description that just restates the title makes the agent fetch and read, which costs tokens and time and gives it a chance to ground on the wrong page.

Why "governed" is the word that matters

A document with no known author and no shape is a rumour, not a source of truth. Governance is what turns a pile of notes into a brain you can ground real work on: every document has a place in the structure and a record of who or what wrote it, so what an agent reads is something your team stands behind, not a scratchpad. Humans own the brain; agents read it and help keep it full.

That principle has to be enforced somewhere, or it's just a style guide people ignore under deadline. Tatara enforces it at the write, with three rules:

  • The required fields are required. No type, no tags, no description, no agent write. Agents get no "save as draft and tidy it later" path that quietly fills the brain with unfiled documents.
  • Custom frontmatter is a closed vocabulary. Any field beyond the universal ones must be registered in the brain first, with a type (text, number, date, datetime, checkbox, select, list). An unregistered key, or a registered key with the wrong kind of value, rejects the entire write. Nobody invents owner_v2 at 2am.
  • Provenance is stamped, not claimed. An agent's write is attributed from the token that authenticated the call. An agent can't set that field, can't smuggle it in through frontmatter, and can't claim a human wrote something. Agent-authored documents carry no human owner, and every mutation records which actor made it.

The last rule is the one that lets you relax about the other two. You can let agents write into the brain because the record always says which writes were theirs.

What happens when an agent gets it wrong?

When an agent's write is wrong, Tatara tells it exactly what to fix, and it fixes it on the next call. This part surprises people: strict validation makes agents more useful, provided the rejection teaches instead of shrugging.

Say an agent tries to file a deal note and puts the contract value in as a string:

{
  "type": "deal-note",
  "folder": "sales",
  "title": "Northwind renewal",
  "description": "Renewal terms and open questions for the Northwind account.",
  "tags": ["sales", "renewals"],
  "frontmatter": { "contract_value": "$4,200 AUD" }
}

The whole write is rejected, so nothing is half-stored. The response carries the reason and the registry itself:

{
  "status": "rejected",
  "field_errors": [
    {
      "key": "contract_value",
      "code": "invalid_value",
      "message": "'contract_value' is a number field — send a finite JSON number like 4200 or 0.85 (no quotes, no units)."
    }
  ],
  "fields": [
    { "key": "contract_value", "type": "number" },
    { "key": "stage", "type": "select", "options": ["open", "won", "lost"] }
  ]
}

The agent now knows the field exists, what type it is, and what the rest of the registry looks like. It resends with 4200 and the write commits. That's one round trip, no human needed, and no malformed document in the brain.

The alternative is to accept the string, store it, and find out six months later that half your deal notes have currency symbols in a numeric field and none of them sort. Rejecting a write is cheap. Cleaning a corpus isn't.

Want to see a governed document in practice?Tatara is the company brain where your team writes down what your company knows.
See how it works →

Does the structure get in the way of writing?

The structure gets in the way less than you'd expect, because there isn't much of it and the writing itself is ordinary. The body is plain Markdown with no special syntax to learn. The declared fields are five short answers, and most of them are obvious the moment you know what you're writing.

It also stays yours. The document is Markdown with frontmatter, so what your team wrote reads fine in any text editor, diffs cleanly, and doesn't need our software to make sense. Governance here is a set of rules about what a document must declare. It isn't a container that holds your words hostage.

The payoff is quiet, and it compounds. Fix a document once and every AI you use gets the fixed version, because they all read from the same source of truth.

THE INVITATION

Give your agents context.

Start free and build the one source of truth every AI you use can read from.

500 documents free / no card required

Angus

Founder of Tatara. Writes about company knowledge, AI agents that do real work, and building shared context a whole team can trust.

KEEP READING

More from the Ledger