AI agent projects rarely fail on model capability. They fail on what the models are given: agents know neither what exists in the organization, nor what has happened, nor what an action changes. They have no memory.
Palantir addressed a version of this problem long before LLMs. Its approach deserves a careful reading: what it solves, and what it leaves open.
The memory problem
An LLM has no state. Its context window is limited and starts from scratch at every session. The usual solutions each have a structural limit.
Vector search (RAG) retrieves passages close to the question. It guarantees neither the completeness of the answer nor the consistency of the retrieved passages; duplicates and contradictions accumulate over time.
Memory files and conversation summaries are free text, without schema or provenance. When two notes contradict each other, nothing settles the matter.
Hand-maintained knowledge graphs have the right structure, but their maintenance cost has always exceeded their value in use. This is the familiar problem of enterprise master data.
Yet deciding takes more than retrieving text. What is needed is the exact list of blocked orders, not the three closest documents. Every figure needs a source, every fact a date, and disagreements between sources need to be kept. These are properties of databases, not of language models.
What Palantir built
Foundry plugs into existing systems and rebuilds a single representation of the activity: the ontology. It contains, first, object types (customer, order, plant, batch) and their relations. In one system the order is called CMD-4512; in another, 4512. The ontology establishes that they are the same object.
It also contains action types, a point that is often overlooked. In Foundry, an action declares its effects: approving an order, reassigning a batch or suspending a supplier each modify a precise list of objects. This answers a concrete question every practitioner runs into. When an agent receives "I treated plot 12 this morning", how does it know what to update? It does not decide. It identifies the event type, and the schema determines the propagation: the entry in the log, the stock decremented, the indicators recomputed, the forecast to recalibrate. The language model understands the input and picks the type; the propagation is mechanical, hence auditable.
AIP, launched in 2023, puts agents to work on this ontology rather than on documents: exhaustive queries, governed writes, traceability.
The limit is the cost of construction. The ontology is modeled by hand, client by client, by dedicated engineers, over months. The approach works, but it remains reserved for states and very large accounts.
A memory with three registers
In practice, a memory that agents can use combines three registers.
The referential: entities and their relations, typed, identified, deduplicated.
The history: dated events, linked to entities, with their outcome. One principle matters particularly here: nothing gets overwritten. A corrected fact keeps its old value and its two dates, the date of validity and the date of recording. The state of the system can be replayed at any date, and past decisions remain auditable.
The working context: the subset recalled for a given question, the only part that enters the model's window. Recall is a structured query over the entities involved, their recent history and comparable episodes, not a similarity search.
A few simple rules complete the picture. Every fact carries its provenance and its status: measured, derived, simulated or assumed. Missing data is recorded as missing, instead of being filled in by generation. Summaries are recomputed from the facts; they do not replace them.
Measured: from a sensor or a source document.
Derived: computed from other facts.
Simulated: produced by the model.
Assumed: inferred, awaiting confirmation.
Three open problems
Construction. The artisanal model does not scale. The serious path is the learned ontology: ingestion agents read what already exists (invoices, business exports, sensor streams, open data), extract the entities, reconcile units and identifiers, and flag what is missing. When an entry matches no type, the agent proposes a schema extension and a human validates it. The schema pools well: from one organization to another in the same business, most of it is already written.
Prediction. An ontology describes the current state. Deciding requires anticipating, hence a predictive layer on top of the memory: mechanistic models where the science exists, learned components elsewhere, continuously recalibrated by data assimilation, the technique that transformed weather forecasting. With a strict division of labor: agents do not compute the numbers. They orchestrate specialized, verifiable computations, and reason on their results.
Trust over time. A synchronized model degrades without warning: regime change, wear, a failing sensor. Assimilation compensates for these gaps without flagging them, and the longer the system has been running, the more the user trusts it. The gap between predictions and reality therefore has to be monitored, distinguishing slow drift, which gets absorbed, from rupture, which triggers an alarm and a diagnosis, and from sensor failure, which is a false alarm to isolate. Repair then has to be targeted, and the alarm switched off once the model is recalibrated, otherwise it ends up ignored.
In summary
The whole forms a coherent stack: a governed memory, typed, dated, sourced; a schema that routes updates; auditable computations; calibrated monitoring; agents under human validation. An ontology maintained and used continuously is the definition of a digital twin, learned rather than built.