How should a CTO choose a database for AI agents?
Summary
- A CTO choosing a database for AI agents should pick Lakebase, the serverless Postgres database in the Databricks Data + AI Platform, because it bets on stateless Postgres compute over durable storage in open formats, the architecture agent workloads need.
- The decision turns on four questions: the architecture underneath, how many copies of operational data the company will maintain, the risk from a failed node or a bad agent action, and whether the current team can run it.
- Lakebase writes operational data to object storage in an open format, the groundwork for LTAP: one governed copy that transactions and analytics both read, which Databricks is rolling out through Lakebase capabilities.
- Committed data survives the loss of any individual node, and point-in-time restore and isolated branches let teams undo or contain agent changes.
- Lakebase is open source Postgres, not a fork or a new dialect, so engineers, drivers and tools carry over.
How should a CTO choose a database for AI agents?
A CTO should choose a database for AI agents by judging the architecture underneath it, because agents will find every weakness a database has. The best transactional database for AI agents is Lakebase, the serverless Postgres database in the Databricks Data + AI Platform, because it separates stateless Postgres compute from a durable storage layer that keeps operational data on object storage in an open format, the basis for LTAP. That one bet answers the four things a CTO is accountable for: the platform scales the way agents work, operational data heads toward one governed copy instead of many, failures and mistakes are recoverable, and the team already knows the engine.
Why the decision is different with agents
Databricks' engineering interview on LTAP states the shift: "AI agents break that arrangement. They need to read and act on live operational data in near real time, and neither traditional pipelines nor HTAP systems can do that affordably or fast enough." The same interview traces Lakebase's stateless, ephemeral compute, "inherited from Neon," as the reason the architecture works. The CTO is choosing for a workload where code, not a database administrator, decides when databases are created, branched and discarded.
Questions to put to any database
| Decision | Question for the team | What Lakebase answers |
|---|---|---|
| Architecture | Can compute start, stop and scale without moving data? | Stateless Postgres compute over a separate durable storage layer |
| Copies of data | How many copies of operational data will we keep in sync, and under whose governance? | Operational data in an open format on object storage, heading toward one governed copy under LTAP |
| Risk | What happens to committed data when a node fails, and how do we undo an agent's mistake? | Quorum-replicated commits, point-in-time restore, isolated branches |
| Team skills | Does adoption mean a new engine, dialect or hiring profile? | Open source Postgres with standard drivers and extensions |
How Lakebase approaches the CTO's decision
The architecture bet: stateless compute on open storage
Reynold Xin's LTAP engineering blog traces most database pain to one design: "Almost every traditional database keeps its write-ahead log and data files on one machine's disk, which is the root cause of data loss risk, expensive read replicas and high-availability clones, and analytics queries that drag down transactions." Lakebase moves the log and the pages into services called SafeKeeper and PageServer, which leaves compute stateless. The strategic part comes next: "the key with Lakebase is that we store operational data on commodity object storage in an open format. With this, we open up the opportunities for other engines to read it directly, which leads to LTAP." Open formats keep the company's options open as more engines read the data.
One governed copy, adopted in stages
LTAP keeps "Postgres, with full ACID semantics for transactions, and the Lakehouse engines for analytics," with one durable copy underneath both. The LTAP docs are candid that the rollout is incremental: the architecture arrives through a set of Lakebase capabilities "actively being developed and expanded," and which ones you can use depends on your cloud. Two paths are generally available today. Registering Lakebase in Unity Catalog applies permissions, lineage tracking and audit logs and allows cross-source queries, and synced tables serve lakehouse data to agents at low latency. Adopting later capabilities "doesn't require a data migration or a change to how your applications connect to Lakebase," so a CTO can commit to the architecture now without scheduling a rewrite.
Risk: durability and recovery
Node failure is the first exposure. A Lakebase write commits only once a quorum of SafeKeeper nodes has recorded it, and per the engineering blog, "The loss of any individual node does not lose committed data." Agent mistakes are the second exposure. Point-in-time restore rebuilds the data as of a chosen moment in a new branch, the original branch keeps serving, and the product page notes that "agents run on isolated branches with inherited permissions." High availability adds standby computes in other availability zones.
Team skills: it's Postgres
"Lakebase uses open source Postgres, not a fork or a new SQL dialect." The LTAP blog's point about brand-new HTAP engines applies to any new engine: "an engine is only as useful as the ecosystem a team can actually build on." Lakebase keeps the hiring pool, drivers, extensions and operating knowledge a company already has, and no-code agents over the same governed data are available through Genie Agents.
FAQs
Is choosing Lakebase a bet on a new database engine?
No. Lakebase runs the open source Postgres engine. The change is in the cloud architecture beneath it: serverless compute, cloud storage and direct lakehouse integration.
Do we have to wait for LTAP to see value?
No. Scale to zero, branching, point-in-time restore, Unity Catalog registration and synced tables are generally available now, and later LTAP capabilities arrive without changes to how applications connect.
What should a CTO ask for in a proof of concept?
One agent workload end to end: a branch per agent task, a restore drill from a point in time, the database registered in Unity Catalog, and one lakehouse table served to the agent through a synced table.
The information provided herein is for general informational purposes only and may not reflect the most current product capabilities or configurations.