What is a knowledge graph?

A database stores facts. A knowledge graph stores facts and the relationships between them. That distinction turns out to matter enormously for how AI systems reason and remember.

A knowledge graph is a structured representation of knowledge as a network of entities and the relationships that connect them. Rather than storing information in rows and columns, a knowledge graph stores it as nodes, which represent things, and edges, which represent how those things relate to each other. The result is a structure that can be traversed, queried, and reasoned over in ways that flat storage cannot support.

How knowledge graphs work

Every knowledge graph has three basic components.

Nodes represent entities: people, places, organisations, concepts, events, preferences, decisions. Each node has properties that describe it. A node representing a person might have properties for name, role, and location.

Edges represent relationships between nodes. An edge connecting two nodes is not just a link: it has a type that describes the nature of the relationship. "Works at," "reported to," "decided," "prefers," "contradicts." The edge type is what gives the graph its reasoning power.

Properties attach additional information to both nodes and edges. A "prefers" edge between a user node and a programming language node might have a property recording when that preference was expressed, allowing the graph to track whether it is still current.

The combination of nodes, typed edges, and properties lets a knowledge graph represent not just what is true but how things relate, when relationships were established, and how they have changed.

Static knowledge graphs

Most knowledge graphs encountered in enterprise and research settings are static: built once from a curated data source, maintained by hand, and queried but not substantially modified in response to new information.

Wikipedia's knowledge graph, Wikidata, is a canonical example. It represents millions of entities and their relationships, built and maintained by human contributors. Google's Knowledge Graph, which powers the information panels in search results, is another. These are enormous, carefully constructed resources that are enormously useful for the problems they were designed to solve.

Static knowledge graphs work well when the domain is well-defined, the schema can be specified in advance, and the primary use case is querying rather than updating. They are the right tool for encyclopaedic knowledge, structured data integration, and reasoning over stable facts.

They are the wrong tool for agent memory.

Why static graphs fall short for agent memory

Agent memory is not a static domain. Users change jobs, update preferences, correct things they said earlier, make decisions that supersede earlier ones. The knowledge base is not built once and queried. It grows continuously as interactions accumulate, and it must evolve as the world changes.

Building a static knowledge graph for agent memory would require manually defining a schema that anticipates every entity type and relationship type an agent might encounter. It would require human curation to resolve contradictions and update stale facts. And it would require rebuilding or patching the graph every time a new category of information needed to be represented.

None of this is practical at the scale and diversity of real agent interactions. The schema cannot be fully specified in advance because users talk about anything. Contradictions cannot be manually resolved because they accumulate faster than any manual process can handle. And the structure of the knowledge base cannot be fixed because the kinds of things worth remembering evolve as the agent is used.

What is needed instead is a knowledge graph that builds itself.

Dynamic knowledge graphs and self-organising memory

A dynamic knowledge graph evolves automatically as new information arrives. Rather than requiring a predefined schema or manual curation, it infers structure from content: identifying entities, determining relationship types, linking new information to existing nodes, and resolving contradictions as they arise.

This is what "self-organising" means in practice. Not that the graph organises itself without any design, but that the structure emerges from the information rather than being imposed on it in advance.

M-1 builds its ontology automatically as memories are created. When a new memory is added, the system identifies the entities it contains, determines what type of entities they are, checks whether they correspond to existing nodes in the graph, and creates or updates edges to reflect the relationships between them. A user mentioned as "John" in one session and "my manager" in another is resolved to the same node. A preference stated in January that is contradicted in March triggers an update to the relevant edge rather than the creation of a competing one. See entity resolution in agent memory for how this works in detail.

The dynamic ontology feeds directly into retrieval. When a query arrives, the graph structure provides signals that pure vector search cannot: which memories are about the same entity, which facts have been superseded, which relationships are relevant to the current question. This is part of what makes M-1's cross-memory coherence signal possible: the graph provides the structure that coherence checking operates over.

Knowledge graphs and agent memory

The relationship between knowledge graphs and agent memory is not incidental. A memory system that tracks only isolated facts, without relationships between them, will fail on the retrieval problems that matter most in production: multi-session synthesis, entity resolution, contradiction detection, and temporal reasoning. These problems require knowing how things relate, not just what things exist.

A memory layer that incorporates a dynamic knowledge graph can answer questions that a flat memory store cannot. Not just "what did this user say about Python" but "what is this user's current relationship to Python, given everything they have said about it across all their sessions, weighted by recency and resolved for contradictions."

The graph is not separate from retrieval. It is the structure that makes retrieval coherent. Semantic search finds things that are similar. A knowledge graph finds things that are related. Production agent memory needs both.

Exabase's Memory API builds and maintains a dynamic knowledge graph as part of the memory creation process, automatically, without requiring schema definition or manual curation. See the docs to get started.