The decision that shapes everything else

Every enterprise says it wants to be its own AI and data platform. Far fewer have made the decision that makes it possible: which layers you must control completely, and which you should rent because they improve every year without you.

At EnterpriseDB (EDB), we drew that line early. We build an open-source, omni-data platform for a living, so the honest test is to run our own business on it before a customer sees it. We call this Customer 0. It is a sequencing rule, not a slogan, and adoption by both people and agents has moved faster than we expected. 

We rent the model, the chat surfaces, and the commodity connectors. They are interchangeable, and the way people work will keep changing. What we own, and will never outsource, is the system of record for how the company understands itself. That lives in four layers: A semantic layer, where the definitions of our data live and are enforced. A context layer—the operating knowledge, policies, acronyms, and verified answers that sit in no schema. The agent stack—the intent routing, tool access, and tracing that decide how a question gets answered and let us inspect every answer. And the learning loop, whi ch turns production questions and human corrections into tested changes to the layers above before a release ships. All of it runs on EDB Postgres AI as one governed data platform. 

The model and the surfaces are rented. The meaning is owned. That is the whole architecture. Sovereignty over the model matters. Sovereignty over the meaning matters more.

The trigger was friction, not fashion

The architectural review did not start with technology. It started with a salesperson trying to answer one customer question and needing four systems to do it: tickets in one place, opportunities in another, product telemetry held by engineering, pricing somewhere else. Hours of manual pulling, colleagues nudged across time zones, often no answer at all.

Working back from that outcome, the requirement was simple to state and hard to deliver: one identity, one semantic layer, one context store, one trace format, many agents, and many surfaces. Analytics and knowledge retrieval run as separate lanes, one against the semantic layer and one against governed documents. They are compartmentalized by intent classification. Ask a question in Slack or in an assistant and you get the same answer with the same evidence, because there is exactly one place where meaning lives. Adding an agent means registering nodes and tools in a graph. Adding a surface means writing a thin client. Neither touches the meaning.

Put the logic where it is deterministic

The question we wrestled with most was where logic belongs. An agent that reads a schema and writes its own SQL will produce an answer. It will also produce a different answer tomorrow, because ARR, churn, and pipeline each have several defensible definitions and the model picks one. The number looks right until finance compares it to the board deck.

We landed firmly. Metric definitions live once, in the semantic layer, and every agent resolves against that. Operating knowledge lives in the context layer: fiscal calendars, which source wins when two disagree, what an acronym means in sales versus support. The agent decides how to interpret a question and which documents matter. It does not decide what revenue means.

That is why the platform underneath has to do real work: a medallion architecture, a single semantic layer, vector search for retrieval, lineage, governance enforcement, and role-based access control so people see only the data they should. All of it in one Postgres-based data platform, not across five vendors.

The agent decides how to answer. The semantic layer decides what the numbers mean. Two agents, one definition, same answer.

Sovereignty is an operating model, not a data center

For a regulated enterprise, owning the meaning also answers the sovereignty question. The semantic layer, the context store, the policies, and every trace stay inside a platform you govern, on infrastructure you choose: on-premises, in your own cloud account, or hybrid. The model can change, the vendor can change, the surface can change; the record of what your data means and who may see it does not leave your perimeter. Governance is enforced in the engine, not promised in a document, and a reviewer can follow one trace from question to answer to every access decision.

Innovation on top, factory underneath, trust in the middle

The operating model is a sandwich. At the top, decentralized AI: Anyone can build and try things with governed connectors and single sign-on, no extra credentials. At the bottom, a centralized AI factory on EDB Postgres AI, where production agents run with system credentials, approved models, controls, and observability. In the middle, trust, risk, and security decide what graduates and under what conditions.

The lanes run in parallel and much will stay at the top. What is constant is that the factory and the experiments read the same semantic and context layer. An experiment does not become a different answer when it becomes a production agent. And because people build on the governed MCP from day one, even prototypes use accurate, timely data.

“I thought maturity would take years. It took months.”

What surprised us

Few people wanted a new interface. The traffic went headless, through the connector into Claude and the Slack app, because people prefer the surfaces they already use. Build for surfaces, not screens. 

And when answers were wrong, the fault was rarely the agent. It was the data: an opportunity with no win-loss reason, a document describing a feature that no longer exists, a new release with no documentation yet. AI did not create the governance problem; it made it visible at speed, because democratized knowledge finds errors as fast as it finds answers. That is why the feedback loop is not only technical observability but domain owners reviewing prompts and answers, and why production corrections become definition changes and evaluation cases before a release ships.  

The lesson has been consistent: An enterprise that wants to be its own data and AI platform, on infrastructure it controls, does not get there by buying a smarter model. It gets there by owning the definitions, the context, and the record of how every answer was produced. 

What a CDO should do first

Decide what you own and what you rent, and write it down. 

Ask any vendor four questions: Can my team read our semantic and context layers as files without your product running? Can I export all of it? Can I write to it and have changes propagate? Does the contract say you will never learn from our definitions, corrections, or traces? If any answer is no, you are buying a beautiful room with no doors.

Put metric definitions in the semantic layer and test them. Build one semantic layer and one context store on a governed platform you control, and let every agent and surface read from it.

Then measure two things. The cost of the next agent, not the polish of the first. And the outcome you started with: time returned to the people asking the questions. Adoption is good. Repurposed time is the point.

Dan Merzlyak is Senior Vice President, Global Head of Data, Analytics, and AI at EDB.

EDB Postgres AI is the sovereign data and AI platform for the agentic enterprise.