Why Your Organization Needs an Ontology
12 min read
Most companies keep the same fact in more places than they realize. A feature is described in the product design, again in the spec, again in the help article and again in the sales deck, each copied from the one before. When the feature changes, one copy gets updated. The rest keep saying what used to be true.
AI is speeding this up. Note-takers summarize calls, and AI drafts specs in minutes. But writing knowledge down was never the hard part. Keeping it true is.

How does a single decision go stale across a company?
Consider a growing startup. The product team writes its product design as a Google Doc: what the product does, meant to be the source of truth. Engineering builds from it. Its system design, written as Markdown in GitHub, says how each part is built, under the four headings of the team's template: Overview, Components, Data and Risks. Its work is tracked as issues in Linear. At the top of the system design, an engineer has pasted a link to the product design. But the link points to the whole document. It does not say which section the system design relies on, and it does not warn anyone when that section changes.
Now take one feature: exports. The product design says they are part of Reports: a user clicks Export and the file downloads straight away. Halfway through the build, engineering finds that large exports time out, so exports become a background job, and the user gets a link by email when the file is ready.
To engineering, this is a build detail. They update the system design and explain why in a Linear comment and at the next stand-up. The product team hears it and knows the product design should change. But the decision already lives in a Linear comment and a stand-up, and keeping the Google Doc in step is nobody's job in particular, so it waits. Meanwhile the product design still says exports download instantly. Support copies that into the help article, sales into the deck, and a customer who signs up for instant exports waits for an email instead and files a ticket.
That is the change failing to travel up, from the system design to the product design that owns it, and every copy made from the product design carries the old promise.
Now run it the other way. Product decides free-plan users can export three reports a month, updates the product design, raises it at sprint planning, and files a Linear issue. An engineer builds the limit into the Export screen and closes the issue. Nothing in that flow touches the system design, and the link at the top of it says nothing, so it still describes exports with no limit. Months later, the next engineer builds automatic exports from the system design, not the product design. The new route skips the Export screen, and free users export as much as they like.
Say someone does remember to update the system design, or an automation has an agent do it when the issue closes. Where does the limit go? The template fixes the four headings, but a heading is not a meaning. To the engineer who updates it, a limit is stored data, so it goes under Data. To the engineer who builds automatic exports, Components is where each part's rules live; they read it, see no limit, and ship none. Both used the template; they just read it differently. An AI agent has the same gap and less to go on. It was not at sprint planning, and nothing defines what a heading or a term is meant to hold, so it assumes from context and memory. It files the limit under Risks and reports the work as done. A guess reads like a fact, and nothing on the page shows the difference.
So one feature went stale in both directions: engineering's change never reached the product design, and product's limit never reached the system design. Nothing carried either one from the document where it landed to the documents that depend on it.
Underneath both failures is the same gap: the meaning that connected these documents lived in people's heads. People fill that gap from memory, and AI fills it with guesses.
What is an organizational ontology?
Knowledge engineers have a name for a shared, written model of what things are and how they relate: an ontology. Applied to a company's documents, an organizational ontology writes down what lived in those heads. It has two parts. A shared dictionary says what each kind of document owns and what each of its sections holds. A map records which section reads which, so documents point to their source instead of copying it, and a change travels up to its owner and down to everything built on it.
Go back to the example with those two parts in mind. Four things were never written down:
Who owns a change. Everyone knew the product design described what users do, but no written rule said so. That belongs in the dictionary.
What the system design reads. It linked the whole product design, not the section it relied on, so nothing carried a change either way: engineering's finding up, product's export limit down. That belongs in the map.
What each section must contain. The system design's template fixed its headings but not what each one means, so two engineers read Data and Components differently and the limit fell between them. That belongs in the dictionary, written into each template.
Which cases a rule covers. Product wrote the limit for every export a free-plan user makes; engineering built it for the Export screen alone, so automatic exports had no rule. That belongs in the dictionary: a rule names a property, not one case.
Part one: define what each document and section holds
The dictionary comes first. You do not define every word, only the ones that decide where work goes: the kinds of documents, and the sections inside them. Each gets one sentence in one form:
A [term] is a [broader term] that’s [what makes it different].
A product design is a design document that says what users can see and do.
A system design is a design document that says how the product is built.
Sections get the same, plus the question they answer and what they leave out, because that is where the example broke:
Features is a product design section that lists each thing users can do and every rule on it, such as a plan limit. It answers "what can a user do, and within what limits?"
Components is a system design section that says how each part works and which rules from the product design it enforces. It answers "what must this part do?" It does not say where data is stored.
Data is a system design section that says what is stored and where. It answers "what do we keep, and where?" It does not hold rules on what users can do.
Run both failures through these definitions. The email link changes what users can do, so it belongs in Features, and the product design owns it, even though the work happened in the system design. The free-plan limit is a rule on what users can do. The counter is data, but the rule is not, so the rule goes in Components, beside the export job, where whoever builds automatic exports will read it. Because each definition names a property, not a list, it decides new cases the same way for every person and every agent.
Part two: map which section reads which
Definitions say who owns a change; the map says where it must travel. A template turns each definition into a shape: the sections every document of that kind must have, and which sections of other documents each one must read. An instance is one real document made from a template, and it inherits the template's definitions, so Components means the same thing in every system design. Every document also has a named owner who approves changes to it.
Here are this company's:
Product design. Features is the source; it reads nothing.
System design. Components must read the product design's Features. A new section, Build findings, must name the Features entry each finding changes; the old template had nowhere to put one.
Help article and sales deck. Each must read the Features entry it describes.
The links are written once, in the templates. Every document inherits them and records what it actually read: which document, which section and which version.
Run the example again with the map in place. Every read records a version, and the product design is at version 3 when everything else is written.
Going up. Engineering records the email link under Build findings, which names the Features entry it changes. That sends it to the product design's owner, who drafts version 4. Everything that read the old entry, the system design's Components and any help article or sales deck, is flagged until it reads the approved version 4.
Coming down. Product adds the free-plan limit as version 5. Components reads Features, so it is flagged until the limit is written into it.
This is less work than it sounds. AI can draft the definitions and templates from the documents you already have, and propose the recorded reads for owners to confirm. After that, whoever writes a document records what it reads at the time. One limit remains. An ontology cannot tell you a definition is right. It can show that every section has one, that every change reached what depends on it, and that someone approved it. Whether the product design is correct is still a person's call.
Why aren't chatbots or AI agents enough to keep documentation current?
Because keeping documentation current takes a teammate, not a tool. Most AI that joins a meeting today is a meeting bot: it listens, then writes a summary.
A meeting bot cannot talk back. At the stand-up it hears "exports will arrive by email" and writes it down, but it cannot ask whether that means every export, and its summary is one more copy owned by nobody. Later, a chatbot asked how exports work answers from the stale product design: "instant download".
An agent works for whoever runs it. With connectors and a session that builds up context, it can read the documents, carry a change, even follow the ontology. But its memory is its user's: what one engineer's agent learned at the stand-up is not what the product manager's agent knows at sprint planning weeks later. And it owns no document, so no one is sure whose job the update is, or who should ask whether automatic exports count.
An Aura talks, and already knows. On 34Five, organizations build their own AI teammates, called Auras. Each has its own personality and job, speaks up in meetings and threads with many people at once, and shares memory with every other Aura and person: what was decided, by whom and where. Through 34Five's marketplace of integrations, it reads and writes in tools such as Google Drive, GitHub, Linear and Slack, and in 34Five's own Company Brain, which is one source among many. Little of what a company knows belongs to one team: the same fact sits in a design, a ticket, a call and a sales deck, each in its own format. Auras turn that scattered, unstructured knowledge into structure that people and AI can both use: definitions, sections and recorded reads, while each document stays where it is. An Aura edits the documents its job owns, and drafts changes into everyone else's for their owners to approve.
One Aura at the stand-up. Replay the stand-up from the story, this time with an Aura on the team. Anthony is the Aura that owns the system design. His personality is curated to work with this engineering team, and his intelligence is built for that job: he knows the system design template, what each section must hold and what it reads, and how this company builds and decides. He helped define that part of the ontology, so he knows which questions to ask and where each fact comes from and must go. Nobody prompts Anthony. When the engineer says exports will now arrive by email, Anthony asks: "Is that every export, or only large ones?" "Every export," the engineer says. A change to what users do belongs to the product design, so before the stand-up ends, Anthony has:
recorded the finding under Build findings, naming the product design's Features entry, and updated the system design in GitHub, pointing the Components read at the version 4 draft so its flag clears once version 4 is approved;
drafted version 4 of the product design in Google Drive, for its owner to approve;
written the reason on the Linear issue.
No new summary, no follow-up to remember: every document the change touches has it, has a draft waiting for its owner, or is flagged for the Aura that owns it.
Now imagine a team of Auras. One Aura works with everyone in its room, but it owns one part of the ontology, set by its job and the intelligence built for it. A change is heard in one place and needed in another, by a different team, weeks later. So give every job its own Aura, each set up the same way for its own part: its own templates, sections and reads, and a clear line between what it owns and what it drafts for someone else. They work in 34Five's own calls and in outside meetings, and help people directly too: Anthony can brief a new engineer from the system design and everything it reads. In the example:
Linda, a project manager Aura, hears the free-plan limit at sprint planning, and she drafts version 5 of the product design for the product manager. That flags Components, so Anthony asks whether automatic exports count. "Every export counts," the product manager says, and Anthony writes it into Components, months before anyone builds them.
A support Aura, which owns the help articles, drafts fixes to the help article and, with sales, to the deck, both of which promised an instant download. It publishes the article once version 4 is approved; the deck waits for its owner in sales.
In this example, both directions hold: engineering's change reaches the product design, and product's limit reaches the system design before anyone builds on it. One AI helps one person. A team of Auras keeps every team, and every agent, working from the same picture.
How do you start building an organizational ontology?
Start with one chain, where the drift already hurts. Take one change from the last few months, like the free-plan limit, and ask it the four questions the example never answered:
Who owns it? Find the one section that should hold it, such as the product design's Features.
What reads it? Find every section, on every platform, that relies on it: designs, tickets, help articles, sales decks. Count the ones that copied it instead of pointing back, and still say the old thing.
Where does it belong in each? Ask two people which heading it goes under. If they disagree, that heading has no written meaning.
Which cases does it cover? Check whether the rule names a property, like every export, or one case, like the Export screen.
Each answer is a piece of the ontology: an owner and a definition for the dictionary, a recorded read for the map. Write them down for that one chain and you have started. Auras can take it from there, and keep it current in every meeting after. See how it works.
About the author: Shivaganesh Nagamandla is a founding AI engineer at 34Five. He architected the ontology layer behind the design of 34Five's multi-agent system, so that many Auras and the people they work with share one structured, current picture of the company as it scales.
Editorial disclosure: I work at 34Five, which builds the Auras described here. The startup in this article is a composite example.