What Foundry Actually Is
Most public explainers describe Palantir Foundry as a dashboard tool, a data lake, or an AI platform, and all three miss the point. Foundry is an ontology-centric operating system for an organization: raw data becomes datasets, datasets are transformed by pipelines, pipelines feed the ontology (a live model of the business's objects, links, and actions), applications and AI agents are built on the ontology, and the output is decisions that write back into operations. This module gives you that mental model in one sitting, with every claim traceable to something we built and verified in the lab. Read it before anything else in this manual.
Field notes from the Avinyr lab. This is the one conceptual module in the foundations track. Every mechanism described below is something we built and verified in the Pipeline Builder and AIP tracks between 2026-09-01 and 2026-09-04. Where we have not touched a thing ourselves, we say so.
[ READ THIS FIRST: THE MISCONCEPTION THIS KILLS ]
Search for Foundry explainers and you get investor-grade fluff: "a central operating system for data", "AI-powered decision making", stock footage of maps and timelines. None of it tells you what the thing does on Tuesday morning when you open it.
Worse are the three wrong models practitioners bring with them:
- Foundry is a dashboard tool. (It makes dashboards the way Excel makes CSVs: possible, not the point.)
- Foundry is a data lake. (It stores data, but storage is the boring half.)
- Foundry is an AI platform. (AIP is real and it is the fastest-moving part, but it stands on a decade of unglamorous data plumbing.)
The right model is one sentence: Foundry turns an organization's raw data into a live, permissioned model of the business, and then lets people and AI act on that model.
[ THE SPINE: FIVE LAYERS, ONE DIRECTION ]
Everything in Foundry hangs off a single pipeline of meaning. Data flows down, decisions flow back up.
SOURCES. Databases, SaaS exports, files, streams, APIs. Foundry connects with Data Connection and HyperAuto, or you drop files in a folder. At this layer the data is still the source system's opinion of the world: table names like asset_tbl, column names like dt_closed.
DATASETS. Foundry's native unit of storage. Every ingest lands as a dataset; every transform reads and writes datasets. Datasets are versioned (Foundry calls the versions transactions) and every build is recorded, so "where did this number come from" is a query, not an archaeology project. We verified this in FM-PB-01: a synthetic CSV became a dataset, and its build history was inspectable end to end.
TRANSFORMS. The logic that turns source-shaped data into business-shaped data. Two doors into the same house: Pipeline Builder (low-code, FM-PB-01 through FM-PB-07) and Code Repositories (Python, SQL, TypeScript, git-backed, FM-PB-06). Transforms chain into pipelines, pipelines build on a schedule or on demand, and every chain is visible in Data Lineage.
THE ONTOLOGY. This is the layer that makes Foundry Foundry. The ontology is a live model of the business: object types (Equipment, Operative, Mission), the links between them, and the actions that change them (close the work order, reassign the operative). It is not a diagram. Applications read it, AI agents reason over it, and actions taken in apps write back through it to the underlying data. In our labs, an ontology edit was visible to an AIP chatbot within the same session.
APPLICATIONS AND AGENTS. Workshop modules, Slate apps, Quiver analyses, Contour explorations, AIP Logic functions, AIP chatbots. This is where humans and agents touch the model. The key fact: they all read the same ontology, so the number in the boardroom app and the number the chatbot quotes are the same number.
Then the loop closes: a decision made in a Workshop app (an action) writes back to the ontology, which writes back to datasets, which downstream pipelines can pick up. Data down, decisions back up. That loop is the whole product.
[ WHY THE ONTOLOGY IS THE POINT ]
Every data platform has layers 1 through 3. Snowflake will store your tables, dbt will transform them, and you can bolt a dashboard on top. What none of them give you is a shared, governed definition of what a thing IS.
In a warehouse, "equipment" is a table. In Foundry, Equipment is an object type with properties, a status that an action can change, links to the Operative maintaining it, and a permission model that follows it everywhere. Build a Workshop app on it and the app understands Equipment. Point an AIP agent at it and the agent understands Equipment. Hire a new analyst in six months and they inherit the definition instead of reverse-engineering a SQL schema.
This is also why Foundry implementations fail in a specific way: teams treat the ontology as an afterthought, mirror their database tables one-to-one into object types, and end up with a very expensive data lake. We built exactly that anti-pattern on purpose in the lab (object type asset_tbl, flagged BAD EXAMPLE in Ontology Manager) so you can see what it looks like. It looks like a database wearing a costume.
[ WHERE AIP FITS ]
AIP is not a separate product, it is a layer of AI apps and assistants that read and act through the same spine. The pieces we have verified hands-on:
- AIP Assist: an assistant embedded in the left rail of every app (ctrl+shift+U). It reads the resource you are looking at.
- AIP Logic: a function builder where you give an LLM instructions, inputs, and tools. Publish the function and anything in Foundry can call it. (FM-AIP-01)
- AIP Chatbot Studio: conversational agents grounded on your ontology and functions. (FM-AIP-02)
- AIP Evals: test suites that grade agent output like software regression tests. (FM-AIP-03)
The reason AIP works better here than a chatbot bolted onto a warehouse is layer 4. The agent does not guess what "open work orders" means from a table name. It queries the ontology, where Work Order is a defined object with defined properties and defined actions. Governance follows too: if you cannot see the object in Workshop, the agent cannot see it for you.
[ EXPECTATION VS REALITY ]
| What you might expect | What Foundry actually is |
|---|---|
| A BI tool with better marketing | An operating model of the business that BI is one consumer of |
| The ontology is an ER diagram for documentation | The ontology is live infrastructure that apps, actions, and AI agents read and write |
| AIP is a chatbot add-on | AIP is a layer that only works because the ontology gives it ground truth |
| Pipelines are the product | Pipelines are plumbing. The product is what the plumbing feeds |
| You can mirror your database schema into it | You can, and it is the most common failure mode we see |
[ FAQ ]
Is Foundry a replacement for my warehouse?
It can be, but that framing undersells it. A warehouse stores and computes. Foundry stores, computes, models, operationalizes, and governs, then lets humans and agents act. Most deployments we see keep some upstream systems and make Foundry the operational layer.
Where does the ontology live technically?
Object types are backed by datasets (or live connections). You define the mapping in Ontology Manager. Change the backing pipeline and the objects update on the next build.
Is this lock-in?
Yes, in the way any operational platform is. Your transforms and ontology definitions live in Foundry's formats. The mitigation is boring discipline: keep raw data exportable, keep business logic readable, and document decisions outside the platform. We practice this in the lab.
Why does everyone say Foundry is expensive?
Because it is priced for organizations, not individuals, and because implementations staffed by generalists burn months. The platform cost is knowable; the implementation cost is where budgets die. That gap is why this manual exists.
[ NOT TESTED ]
- Gotham, Apollo, and Foundry's classified-network variants. Different products and deployment modes; we have no access and make no claims.
- Performance at billions of rows. Our lab is a developer-scale enrollment. Nothing here is a benchmark.
- Pricing. We do not publish numbers we cannot verify, and Palantir does not publish them either.
[ NET POSITION ]
Foundry is five layers on one spine: sources, datasets, transforms, ontology, applications, with decisions writing back up. Learn the spine and every app in the catalog becomes a tool with a job instead of a name in a sales deck. The ontology is the layer that matters, the layer that fails first when implementations are staffed by people who think this is a dashboard tool, and the layer this manual spends the most time on. Next: FM-ST-02 gets you a login, and FM-ST-03 walks every app on the box.