> ## Documentation Index
> Fetch the complete documentation index at: https://docs.get-exo.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Concepts
> What Exo stores, and why it keeps a graph of how a person thinks instead of an index of what they wrote.
A vector store answers one question well: which passages look like this query. That is enough when the answer is a fact sitting in a document. It runs out when the answer depends on a person: what they decided, what they used to think, which of their own positions still disagree with each other, and how they would say it.
Exo is built for that second case. It stores a person's content as a graph of claims and relations, then runs a background cycle over that graph to discover structure nobody typed in: the topics their knowledge organises into, the eras their history falls into, the axes their thinking varies along, and the points where they contradict themselves. A retrieval reads that structure, so the response carries the reasoning and the conflicts alongside the passages.
## What Exo stores
Five kinds of thing, in one substrate.
| | What it is | Where you read it |
| ------------------------ | -------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
| **Nodes** | A piece of content as a claim that can be revised, with an authority weight and a provenance stamp | [`GET /v1/graph/nodes`](/api-reference/graph/list-graph-nodes) |
| **Edges** | A typed, directed relation between two nodes, either discovered or asserted by you | [`GET /v1/graph/edges`](/api-reference/graph/list-graph-edges) |
| **Discovered structure** | Domains, phases and basins: clusters Exo found in the content rather than labels you supplied | [`GET /v1/recall/{recall_type}`](/api-reference/recall/get-recall) |
| **Tensions** | Two positions the same subject held that disagree, kept side by side rather than reconciled | [`GET /v1/contradictions`](/api-reference/insights/list-contradictions) |
| **Provenance** | Where every node came from, every edit made to it, and what it superseded | [`GET /v1/graph/nodes/{id}/history`](/api-reference/graph/get-node-history) |
The four discovered views are one operation, not four routes. [`GET /v1/recall/{recall_type}`](/api-reference/recall/get-recall) serves `identity`, `graph`, `insights` and `temporal` from the same endpoint, and every response carries a `type` field naming which of the four shapes you got. Contradictions and proposals live under the `insights` tag in the reference rather than a tag of their own.
That `type` field is the discriminator to branch on, and each view fills in independently as the background cycle warms it:
```json 200 application/json theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
{ "type": "graph", "nodeCount": 846, "edgeCount": 3117, "domainCount": 12, "nodes": [], "edges": [], "domains": [] }
{ "type": "identity", "manifoldState": null, "voiceProfile": null, "recentPatterns": [], "basinHistory": [], "contradictions": [] }
{ "type": "temporal", "phases": [] }
{ "type": "insights", "items": [] }
```
Those nulls and empty arrays are what a subject looks like before the cognition cycle has run. They are the honest answer for a layer that does not exist yet, not an error, and every concept page below says what its own layer needs before it fills in.
## How content becomes cognition
```mermaid theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
flowchart LR
A[Content in
text, files, sessions] --> B[Chunk
and embed]
B --> C[Nodes and edges
the knowledge graph]
C --> D[Background
cognition cycle]
D --> E[Domains
Phases
Manifold
Insights
Contradictions]
C --> F[Retrieve]
E --> F
F --> G[Sources
Contradictions
Cognition]
classDef focus stroke-width:2px;
class D focus;
```
Ingestion is the fast path: content arrives, gets chunked, embedded and linked, and is retrievable as soon as its job succeeds. The cognition cycle is the slow path: it runs in the background and fills in the discovered layers. That split is why a freshly imported subject can retrieve immediately but gets empty collections from the recall views for a while. It is not an error, and [Memory lifecycle](/concepts/memory-lifecycle) says what to watch instead of guessing.
## The seven objects
These are the objects Exo returns that a passage index has no way to express. Each one gets a page, a real payload, and a plain statement of what is not true yet.
Why the answer, not only what: the nodes the model settled on, how strongly it settled, and whether it thought fast or slow.
Two positions the same person held, kept side by side with a salience score instead of quietly reconciled.
What someone used to think, what replaced it, when, and where the authority went.
The axes this person's thinking actually varies along, discovered from their content rather than chosen from a personality list.
The eras of their history, clustered from the dates inside the content.
A ready-to-inject prompt that makes your own model reason and sound like them.
The recurring ways a team's coding agents go wrong, clustered from evidence and reported without naming anyone.
## The model underneath
Nodes, edges, domains and authority: the substrate everything else reads.
Ingest, edit, supersede, forget, undelete, purge. The full life of one node.
Which engine served your call, and what degraded actually means.
Why the background cycle proposes connections instead of asserting them.
Orgs, users and subjects: one memory per end user of your product.
The per-org model, when it serves, when it goes stale, and what training costs you.
## Next
Read [The knowledge graph](/concepts/knowledge-graph) first. Every other page on this tab reads from it.