Both Snowflake and Databricks spent the year racing to support the same open table format, open catalog protocol, and cross-engine governance model. Snowflake shipped Iceberg v3 to general availability at its June Summit and rebuilt its Horizon Catalog on Apache Polaris for two-way Iceberg interoperability. Databricks pushed Managed, Foreign, and v3 Iceberg through Unity Catalog and introduced cross-engine access controls enforced over the Iceberg REST APIs. Two platforms that compete on almost everything converged on one idea: the data, catalog, and governance have to be open, because agents need to reach across systems.
This convergence is important and as a result, the closed platform is losing, and the companies that built the closed platforms are the ones telling you so with their roadmaps.
Agentic analytics needs four things, and how lock-in blocks the last one
Strip the agentic AI hype down and an agent that answers business questions over your data needs four concrete things:
- Governed context, so it knows which numbers are trustworthy and who is allowed to see them.
- Reusable semantics, so “revenue” means the same thing whether the agent reads it or a dashboard does.
- Fast query access, because an agent that waits 30 seconds per question is useless in a conversation.
- Portability, so the same data serves the model you use today and the one you switch to next quarter.
A single closed platform can give you the first three inside its own walls, but it can’t give you the fourth, and that decides who wins. Models change every few months so the lab with the best model in March is not always the best in September. If your governed, semantically rich data lives in a format only one platform can read, every time you switch a model, it becomes a migration. Also, open architecture turns that migration into a configuration change.
The data format no longer owns the customer
The clearest signal came from analysts summarizing Snowflake’s own Summit announcements. One framed it bluntly and stated that Snowflake is preparing for a world where it no longer needs to own the data format to own the customer relationship. From that perspective, Iceberg v3 support is table stakes. The market already moved to open formats, so the fight shifted up the stack to context, governance, and identity.
Both vendors now say the same thing differently. Snowflake describes a future where metadata, lineage, identity, and policy travel with the agent rather than staying locked inside the platform where the data started. Databricks markets Unity Catalog on “write once, read anywhere” and bidirectional federation across Snowflake, Glue, and other catalogs. Read those two positions side by side and the conclusion writes itself. The value is no longer the storage. The value is governed and portable access to data that lives in open formats.
Why “open inside one vendor” is not open
Both platforms now wrap open formats in language that sounds fully open while keeping the gravity inside their own walls. A managed Iceberg table that only performs well through one vendor’s engine is open in name and closed in practice. Bidirectional federation that routes everything back through a single catalog still concentrates control in one place. The open table format is necessary but it’s not sufficient. What matters is whether you can run your governance, semantics, and fast queries across engines without one platform sitting in the middle of every path.
Can a second engine read your data, apply the same access policies, and return results at interactive speed without copying anything? If the answer requires routing through the platform that stored the data, you bought open formats and kept the lock-in.
Picture the setup that survives three model generations. Your data sits in Iceberg on your own object storage. An open catalog, Apache Polaris or something compatible, tracks tables and enforces policy through the Iceberg REST APIs that every serious engine now speaks. A semantic layer defines your metrics once, so agents and dashboards read the same definitions. Any engine and any AI agent connecting through a protocol like MCP, can reach that data under consistent governance.
In that scenario, switching models costs nothing structural and neither does adding an engine because the data never moves. Governance does not fragment across copies either. This is the design both Snowflake and Databricks now gesture toward, and it is the design that open-first platforms were built upon.
The open-first platforms got there first
The platforms adding interoperability in 2026 are reacting to a thesis that open-first vendors shipped years earlier. Apache Arrow, Apache Iceberg, and Apache Polaris did not come from the closed platforms. They came from a contributor community that bet on open standards before the agentic moment made the bet look obvious.
The reason this matters is positioning, not branding. A platform designed around open standards does not have to walk back lock-in to chase agents. Its caveats are fewer by construction: no proprietary storage to migrate off, no single catalog every query must traverse, no format that only one engine reads well. The closed platforms can copy the format and the protocol, yet they cannot easily copy the absence of gravity.
Bet on the architecture, not the model
The temptation is to select the platform with the best AI demo, but that is the wrong bet. Demos age in months and the model you marry today gets outclassed by next year. The cost of that divorce depends entirely on how open your data was when you signed up.
So, judge platforms by a different question. Not “whose agent is smartest today” but “how cheaply can I change my mind.” Open formats, open catalogs, portable governance, and query access that does not depend on one vendor’s engine all push that cost toward zero. Closed platforms, however polished their AI, push it back up.
The vendors already voted with their roadmaps. Snowflake and Databricks spent 2026 making their walled gardens look like open fields, because their customers demanded data that AI can reach across systems. The lesson is not that those vendors became open, but that open won, and even the giants had to follow. To avoid costly mistakes, best to build for the architecture that gave them no choice.
