Building the AI-ready data platform
Part 2 of 2 · The Agentic Data Stack
On this page
An agent can write valid SQL and still choose the wrong table. In part 1 I argued that data is becoming the bottleneck. Here’s what I’d build to address it.
Think back to part 1’s coworker. Deploying an agent is like onboarding a capable new hire. In a well-run company, they get documentation, clear owners, runbooks and colleagues who know the caveats, so they make good decisions quickly. In a chaotic one, they make avoidable mistakes for months, however talented they are. The model is the talent. The data platform is the onboarding. Without descriptions, lineage, freshness targets and clear contracts, the agent is capable but lost.
This essay is about the analytical side: the tables and pipelines agents read. For the database agents write to, their memory and their workspace, see my later series Agents and the data layer.
What agent builders hit first
If you build agents, you’ve probably hit these, without calling them data problems:
- It works in the notebook and breaks in production. You tune the prompt for days. The real issue is that production data is stale, incomplete or shaped differently from your sample.
- You can’t explain a bad decision. Hours in the traces later, the cause is a table someone changed upstream: a renamed column, a new filter, a broken pipeline.
- Five tables look right. None has a description or lineage. You pick one, it’s the wrong one, and the agent produces plausible answers that are quietly wrong.
- Your evals pass on Tuesday and fail on Thursday. The agent didn’t change. The data did.
These are data-layer problems that show up through the agent. You can build agents without talking to your data team. You can’t build ones that hold up in production without them, and no amount of prompt engineering fixes a broken table.
What “AI-ready” means
“AI-ready” has become a marketing label, so here’s what I mean by it. In an AI-ready data platform:
- Every dataset is discoverable: an agent, or a person, can find the right table without asking around.
- Every table is described: not just names and types, but meaning, freshness and known caveats.
- Every dataset the agent uses has lineage: its sources and transformations are recorded.
- Every access is governed: permissions, audit trails and retention are enforced by the platform, not added later.
- Every pipeline has service levels: freshness, completeness and cost are measured and enforced.
None of this is new. Data engineers have asked for it for years. Agents make the cost of skipping it immediate, because they act on bad data at machine speed.
Why the lakehouse
For most teams, I think the lakehouse is the most natural foundation for this. A lakehouse keeps data in open formats on object storage, and lets SQL, Spark, Python and machine learning tools work on the same tables, with a shared catalog and permissions if you configure each access path to enforce them. That fits agent workloads in five ways:
- Shared analytical tables. In a split setup, the same customer lives in a lake, a warehouse and a feature store, each with its own schema and freshness. An agent asking for “the current cancellation rate” shouldn’t have to know which one to trust.
- History and the present together. A pricing agent needs last quarter’s seasonal trend and today’s bookings. Streaming ingestion into the same tables avoids stitching two pipelines together.
- Open formats. Many engines can read Delta Lake and Apache Iceberg tables without exporting them, though support varies by engine and table feature. That matters when your agents, your evals and your business logic all read the same tables.
- Governance in the platform. Route agent queries through governed access paths, enforce the authority they were delegated, and record which identity queried which table.
- Cheap long-term storage. Agents produce a lot of decision data that has to be kept for audit but is rarely read. Object storage keeps that affordable.
It isn’t the only option. A well-governed warehouse with clear metric definitions can meet these requirements too. I favour a lakehouse when several engines need shared access to the same analytical tables.
Three things to build on top
Architecture isn’t enough on its own. A lakehouse still leaves agents guessing if nobody describes its tables. Three things make it AI-ready.
Governance as infrastructure
Every agent query, decision and tool call needs to be traceable, less for a regulator than for you, when something breaks. Suppose the pricing agent at Shiba Resorts, the made-up company from part 1, drops a luxury suite to $12 because it read a test row from an unvalidated staging table. The postmortem has to answer: what did it see, how fresh was it, what was it allowed to do, and who else used its output?
That takes access control enforced by the platform, with agents holding only the permissions of the role they act for. It takes audit trails that are automatic, lineage from raw data through to the agent’s output, and retention rules for the data agents produce. Without them, every bad decision is a manual reconstruction.
Tables that explain themselves
I’d start here: describe the tables the agent actually uses. For that pricing agent, a description has to separate confirmed bookings from test rows. It needs to say:
- What a table represents. Not “booking_events” but “all confirmed bookings, excluding test accounts, one row per reservation”.
- How it’s produced. Which pipeline, which sources, what assumptions.
- When it’s fresh. “Refreshed daily by 06:00 UTC”, not “it gets updated”.
- What the caveats are. “Undercounts mobile bookings before July because of a tracking bug.”
Without this, agents guess, pick the wrong table, join on the wrong key and return answers that look right. Retrieval doesn’t fix it on its own: it can only find descriptions that exist. Every team can bolt checks onto its own agent, but that’s each team rebuilding what the platform should provide once.
The platform as a product
A pipeline feeding a morning dashboard can survive an overnight delay. One feeding an agent that changes prices needs a fix before the next decision. If the bookings table misses its freshness target, pause price changes and tell its owner. Treat the platform like a product: freshness targets that are measured, spend attributed to agent workloads, monitoring across the whole loop, and contracts that tell agent developers about a schema change before their agent finds it.
Agent output also needs a home. Each decision trace carries the input, the tool calls, the retrieved context, the output and the checks applied. That’s richer than a log line, and it feeds back into the system that produced it. Give these decision traces an owner, a retention policy and a freshness target, as you would any other dataset.
One company’s evidence
OpenAI described its own version of this in Inside our in-house data agent, published in early 2026. The agent lets people across Engineering, Product and Research ask questions of a platform that, by OpenAI’s own figures, serves more than 3,500 internal users across 70,000 datasets and over 600 petabytes.
The most useful part of the post isn’t the model. It’s the six layers of context OpenAI built so the agent could work:
- Table usage: schemas, lineage and how tables are usually queried.
- Human annotations: descriptions from domain experts.
- Codex enrichment: the agent reads the code that produces each table, to learn what the data really means.
- Institutional knowledge: launch context, incidents and metric definitions from internal documents.
- Memory: corrections from earlier conversations, kept and reused.
- Runtime context: live queries when the stored context isn’t enough.
The strongest connection is to tables that explain themselves, and layers 2 and 3 took real people and tooling, not a feature flag. In OpenAI’s telling, without this context the agent got basic things wrong, like user counts and internal terminology.
I read this as evidence that context engineering belongs in the platform team’s work. It doesn’t settle which storage architecture to choose. And it doesn’t need OpenAI’s scale: 500 undescribed tables will trip up an agent too.
The real advantage
My bet is that company-specific data work will stay valuable even as models improve. Your schemas, lineage, metadata, permissions and freshness targets are specific to your business. Vendors can supply the tools, but your team still has to define what the data means and when agents may use it.
Models and data platforms limit each other. If your agent keeps choosing stale or ambiguous tables, I’d invest next in descriptions, permissions and freshness checks.
If you’re working out what your data platform needs for agents, or already building it, I’d like to hear about it. Find me @gcdaii.
Sources
Checked on 2026-10-25.
- OpenAI, Inside our in-house data agent, early 2026. Figures are OpenAI’s own.
- Delta Lake, Integrations, no date shown.
- Apache Iceberg, Multi-engine support, no date shown.
Disclosure: I work at Databricks, which builds on the lakehouse architecture this essay argues for.
continue reading
The watch shouldn't be in a ready room: illegal states in agentic systems
When agents write records about the real world, the safest fix is to make the bad record impossible to write, not to repair it later. A hotel story and one small diagram.
Is your data layer ready for agents? The case for Lakebase
Agents need a disposable workspace and a durable record. Here's where Databricks Lakebase fits, in plain terms, and what it still leaves to you.
When the database's newest user is an agent
When a whole company books travel through agents, the database gets a new kind of user: many, fast, and often wrong. What that asks of the data layer, and why branching alone isn't enough.