Company Knowledge Graphs for AI Agents: Start With Five Entity Types
A small knowledge graph beats plain documents when agents must link customers, orders and rules. Start with five entity types tied to one task.

A knowledge graph for AI agents is a small set of named things your business works with, such as customers, orders, products and rules, plus explicit links between them. It beats plain documents when an agent must join facts that live in different records, like which account a request belongs to and which contract version applies. Start with five entity types, tie them to one task, and expand only when a failure shows the graph is missing something.
Key takeaways
- A knowledge graph earns its place when answers depend on relationships between records, not on the wording of one document.
- Start with five entity types tied to one task, not with the whole company.
- Give every entity an identifier, a named owner and a source of truth in one of your systems.
- Keep the set small enough that a person can review it in one sitting each month.
- Keep plain documents for policies and tone, and use the graph for the questions that begin with which one, for whom and as of when.
When plain documents are enough
Plain documents work well when the answer sits inside one text. A returns policy, a cleaning procedure, a brand voice guide or a onboarding checklist can be retrieved, read and quoted without much structure. Most company agents should start this way, because a clean folder of current documents is cheaper to maintain than any graph and already answers a large share of routine questions.
Documents also work when the facts rarely change and nobody needs to combine them. If the agent only explains how a process works, a well-organized set of documents with clear versions is usually enough. The mistakes at this stage are usually about stale versions and unclear ownership, not about missing structure. Those problems deserve attention first, and the guide on how to give an AI agent a reliable source of truth covers them in practical terms.
When a small graph beats documents
Documents struggle when the answer lives between records. Consider a staff question such as: which open orders belong to the account that asked for a new delivery address, and has that account accepted the current terms? The agent must connect a customer, an order, a contract clause and a date. Text search can find each piece separately, but it does not store the join. The agent may then pair a clause from an old contract with a new order and produce an answer that reads well and is wrong.
A graph stores that join explicitly. This order belongs to this account, this account is bound by this contract version, and this version replaced the earlier one on a known date. The agent does not need to infer the connection from wording, which removes a whole class of errors. Identity also matters here, because the same customer may appear under several names in your systems. The reasoning behind customer identity matching rules is a good companion to any graph design.
Use this short decision guide before building anything:
- Choose documents when the answer is contained in one text and that text changes rarely.
- Choose a small graph when the answer requires joining two or more records that the agent must not confuse.
- Choose both when the rules live in documents but the facts they apply to live in operational systems.
- Wait when you cannot yet name the owner of the facts. A graph with unowned records will decay quickly.
The five entity types to start with
For most small and mid-sized companies, five entity types cover a first useful task. Each one should map to a thing that staff already look up by hand.
- Person or account holder: who is asking, which role they hold and what they are allowed to see.
- Customer or organization: the external party, with the identifiers your systems already use.
- Order, job or case: the unit of work the agent touches, with its current status.
- Product, asset or service: what the work is about, including the version or model that applies.
- Rule or policy: a dated, owned statement that governs the work, linked to the document that states it.
Keep the relations between these types few and explicit at first. A person acts on an order, an order concerns a product, an account is bound by a rule. Resist the urge to add entity types for every concept in the company. Each extra type adds maintenance, another owner and another way to be wrong. You can add a sixth type later, once the first task is passing review.
Five entity types are a starting constraint, not a theory of how companies should be modeled.
A step-by-step plan for the first graph
The most reliable path is to begin from one task and work backward to the data. The following sequence keeps the scope small enough to finish and review.
- Pick the single task the agent will handle first, and write down the exact questions it must answer.
- List the records a skilled person checks today to answer those questions, including the systems where they look.
- Map those records to the five entity types, and drop anything the task does not need.
- Assign each entity an identifier, a named owner and the system that is the source of truth for it.
- Define the allowed relations, and forbid any relation that is not on the list until someone has a reason to add it.
- Load a sample of a few dozen records and ask the agent the questions from the first step.
- Log every wrong or missing answer, then correct the record or relation at its source rather than only adjusting the prompt.
- Add a new entity type only after the first task has passed its review on a fixed set of questions.
The last two steps matter most. A graph that never gets tested against real questions becomes a diagram that looks right and answers poorly. For the test set, a short list of real questions with known good answers, the approach in how to build a golden test set for your AI workflow works well.
Illustrative scenario: a repeat order that should not ship
The following scenario is illustrative and does not describe a specific company. A small distributor uses an agent to answer staff questions about repeat orders. The company has a product catalog and a terms page. The catalog marks an item as discontinued, and an email from a supplier mentions an approved substitute. The agent, reading both documents, offers the substitute on a repeat order for an account whose contract forbids substitutions.
In a graph version, the product entity carries a replacement chain that records the substitute as a proposal rather than an approval. The rule entity for the account states that substitutions need staff approval, and the relation between the account and that rule is explicit. When asked, the agent can say which rule applies, why the substitute is not automatic, and who must approve it. The fix was not a longer prompt. It was a relation, an owner for the substitution rule and a test question added to the set.
Who may change the graph
An agent that can edit its own knowledge needs the same discipline as any system user. The safe default is that the agent reads the graph, proposes changes and a person approves them. The OWASP authorization guidance emphasizes least privilege and checking access on every request, and both principles apply directly to graph writes. A proposal to change a rule should show the old value, the new value, the source and the requester.
Permissions should also follow roles. A warehouse lead may see stock relations that a sales assistant cannot, and a customer-facing agent should not see internal margin rules at all. The structure of role-based access in memory access for company AI agents applies to graph entities as well as to documents. Keep out of the graph any personal or regulated data that the task does not need, and follow the guidance on sensitive data that should never be stored in agent memory.
How Be Human handles it, and where to start
Be Human designs the first entity set around one useful role, then defines the memory and tools that role needs, the approval boundaries for any change and a success criterion that someone can observe. After launch, the managed approach covers monitoring, recurring evaluations on the question set, permission reviews, maintenance of the source connections and controlled updates when a rule or system changes. The work stays remote, in English or Portuguese, and it stays under your control at every step.
If you are unsure which task should come first, the free Be Human AI diagnostic will help you find the first task worth handing to an agent.
Frequently asked questions
Do I need a graph database to start? You do not. A small graph can be stored as tables with identifiers and relation tables, and the storage choice matters less than the discipline of owners, identifiers and review. Move to a dedicated store only when the tables become hard to maintain or the relations grow beyond what your team can review.
How is a knowledge graph different from embeddings? Embeddings find text that resembles a question, which is useful for locating relevant documents. A graph stores explicit links between records, such as which order belongs to which account. The two often work together: embeddings find the candidate documents, and the graph confirms which record and which rule apply.
How often should the graph be reviewed? Review the entity list and relations on a fixed schedule, such as monthly, and review any change to a rule or source system as it happens. Assign one named owner per entity type so that someone is accountable for stale or disputed records, and record the date of each review.
What should I do when the agent answers incorrectly from the graph? Treat the error as a data or relation problem first. Log the question, the answer and the records the agent used, then correct the source or the relation, and rerun the same question in your test set before closing the issue.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


