On June 16, 2026, Databricks announced OpenSharing, the next evolution of Delta Sharing, now an independent open-source project under the Linux Foundation. The headline is bigger than it looks. OpenSharing doesn't just share tables and files anymore. It shares models, agents, and skills across any cloud, any vendor, and any format. That is a precise statement about where enterprise AI is going: organizations are no longer exchanging datasets, they are exchanging the autonomous logic that acts on data. It is the right protocol for that future. It also quietly raises a question the protocol itself doesn't answer. When another company's agent acts on what you shared, can anyone prove the asset it consumed was unaltered?
Why this matters now
Delta Sharing was, by any measure, a success. Databricks reports more than 28,000 data recipients and that 33% of shares now flow across platforms through open connectors. It proved a thesis that took the industry years to accept: enterprises will choose open protocols over locked-in ones for data exchange. OpenSharing extends that bet from data to the full AI stack.
The timing is not incidental. Enterprise AI has crossed from demos into operations. Agents now read shared data, invoke shared skills, and trigger actions across organizational boundaries with minimal human review. That shift changes the trust requirement. When a human analyst opened a shared table, a human judged whether the numbers looked right. When an autonomous agent consumes a shared model or dataset and acts on it, there is no human in the loop to catch a corrupted input, a silently swapped version, or a tampered artifact.
Regulators have noticed. The EU AI Act's high-risk obligations reach full enforcement on August 2, 2026. A parliamentary deferral approved June 16, 2026 would push standalone Annex III obligations to December 2, 2027, but it takes legal effect only after Council adoption and Official Journal publication, expected July 2026. Until then, August 2, 2026 remains the binding date. Article 10 requires documented, auditable governance of the data used to train, validate, and test high-risk systems, and where that data was selected, prepared, and modified must be traceable. Non-compliance with high-risk obligations carries penalties of up to €15 million or 3% of global turnover (the higher figure applies). Sharing data and AI assets across company lines, under that regime, is no longer just an engineering convenience. It is an evidentiary obligation that follows the asset wherever it travels.
What OpenSharing actually is?
OpenSharing is an open protocol for sharing data and AI assets (datasets, models, agents, and Genie Agents) across clouds, vendors, and formats without copying the underlying data. It natively supports Delta Lake, Apache Iceberg, and Parquet, so data stays where it lives and recipients query it live from their own tools. The open-source specification is hosted by the Linux Foundation; Databricks ships an enterprise implementation governed end-to-end by Unity Catalog.
That definition is worth sitting with, because the scope expansion is the whole story. Delta Sharing was built for a world of tables and files. OpenSharing is built for a world where the unit of exchange is capability: a Genie Agent shared with its semantic context and business logic intact, a model shared for downstream inference, a skill shared for another company's agent to invoke. Databricks added real engineering muscle around this. SecureConnect is a managed proxy that removes per-recipient firewall configuration, and Global Distribution replicates to local replicas so recipients query without egress fees. The on-prem Storage Ecosystem brings the same governance to data that can't move, with a launch cohort of on-premises storage vendors already shipping implementations at GA.
This is a strong release. It is genuinely open, it solves real distribution pain, and it meets partners where their data already lives. None of what follows is a criticism of that. It's an observation about what sits one layer down.
Is Databricks OpenSharing data auditable?
Here is the distinction that matters: OpenSharing, governed by Unity Catalog, gives you governance. It audits every access, enforces row- and column-level controls, and ensures compliance policies travel with each shared asset. That is access control and access logging, and it is excellent at both. What it does not provide is independent auditability: cryptographic proof, checkable by an outside party, that the asset a recipient consumed is the exact, unaltered asset the provider published, without that outside party having to trust the provider's platform or its logs.
The difference is subtle and decisive. An audit log answers "who accessed this, according to the system that owns the log." Auditability answers "is this the real, unmodified asset, according to math that anyone can check." In a single-platform world, where provider and recipient both live inside the same governed estate, the first is sufficient, because you already trust the platform. In the open, cross-vendor, agent-to-agent world OpenSharing is explicitly built for, the recipient does not necessarily trust the provider's platform. That is the entire point of an open protocol. And the moment trust spans organizational boundaries, "our audit log says so" stops being a complete answer.
Governed is not the same as auditable. Shared is not the same as provably unaltered. A provider can share a model, log every access, and enforce every policy, and a recipient still has no operator-independent way to prove the model weights they pulled are the weights the provider intended, or to reconstruct, after the fact, the lineage of what changed and when. The governance layer is internal by design. Auditability, to be worth anything across a trust boundary, has to be external.
How do you prove shared AI data wasn't altered?
You prove it the same way the rest of the internet proves integrity across untrusted boundaries: with content-addressing and an immutable, independently checkable record, not with a log you have to take on faith.
Concretely, three properties have to hold. First, content addressing: each asset is identified by a cryptographic hash of its contents (a Content Identifier, or CID), so a changed byte produces a different CID and tampering is self-evident rather than something you have to detect. Second, immutability with an audit trail an outsider can verify: a record of what was written and when that no single operator, including the storage provider, can silently rewrite. Third, portability of that proof: the auditability has to travel with the asset across clouds and vendors, not live inside one platform's control plane, because the whole premise of open sharing is that the asset leaves the platform.
This is exactly the gap that immutable, content-addressed storage is built to close. When the underlying asset carries its own cryptographic identity and its provenance is anchored on an immutable storage ledger, a recipient, a regulator, or another company's agent can verify integrity and lineage without trusting the sharer. Because the asset is content-addressed, a changed byte produces a different CID, and that mismatch is detectable by anyone with access, maintained across independent nodes rather than in one operator's database. The governance layer still decides who may access the asset. The auditability layer proves what the asset is. They are complementary, not competing.
The agentic era raises the stakes, not just the volume
It is tempting to file auditability under "nice to have." Agentic workflows make it a structural requirement. Consider what OpenSharing now puts in motion: Company A shares a Genie Agent (with its semantic context and reusable business logic) to Company B, whose agents invoke it autonomously and chain its outputs into decisions that touch customers, money, or regulated processes. If the shared logic or the data behind it is altered, corrupted, or silently versioned between share and consumption, the downstream agent has no instinct that says "this looks wrong." It acts. And when something goes wrong, the forensic question is brutal: which version of which shared asset did the agent actually act on, and can you prove it?
This is the same lesson the industry is learning across every adjacent layer. Agent identity, agent authority, agent payment, and agent governance all now have named owners and emerging standards. The one primitive still without an owner is the integrity of the data the agent reads. Even within the lakehouse, the trend points the same direction. Apache Iceberg v3 added native Row Lineage to track how table data changes across versions, evidence that the market increasingly wants to answer "what changed" as a first-class question. Row lineage tells you what changed inside the catalog. It does not, on its own, give an outside party cryptographic proof that the bytes are unaltered. The closer the ecosystem gets to autonomous, cross-organizational AI, the more the unanswered question becomes: who verifies the data, independently of whoever stored it?
An open protocol leaves room for the layer beneath it
Here is why OpenSharing is good news for anyone building auditable infrastructure. Because the protocol is open, a Linux Foundation specification any vendor can implement, Databricks has not closed the stack. It has defined the seam. Storage vendors have already implemented the OpenSharing server to join the Storage Ecosystem. Any S3-compatible storage layer can do the same.
That means the auditability layer does not have to fight the sharing layer. It plugs in beneath it. A storage provider that implements the open protocol and adds content-addressed immutability and an immutable storage ledger brings something none of the current launch partners offer: operator-independent proof that the shared asset is exactly what it claims to be. Because each asset is content-addressed, any modification produces a different CID, and that mismatch is independently detectable by anyone with access, with the record held across independent nodes rather than in a single vendor's log. The sharing protocol handles distribution and governance. The storage substrate handles the auditable record of what the asset is. The asset gets both, and the recipient gets an independently checkable record that survives leaving the provider's platform.
The Akave perspective: govern with Unity Catalog, prove it with Akave
We've argued for a while that in an agentic world, storage is not a commodity beneath the stack. It's the auditable truth layer the whole stack depends on. OpenSharing sharpens that argument better than we could have. Databricks has made the case, at scale, that AI assets must move openly across organizational boundaries. The natural next question, and how does the recipient know what they got is real?, is the one Akave Cloud is built to answer. You can test the storage-layer answer against your own data with a free trial.
Akave is S3-compatible object storage (through our O3 gateway) with three properties OpenSharing's distribution model needs at the substrate. First, CID-tagged immutability: every shared asset carries a cryptographic identity derived from its contents, so a changed byte produces a different CID and any modification is independently detectable by anyone with access, not something you have to trust a log to surface. Second, an immutable storage ledger: the provenance of what was written and when is recorded across independent nodes, so no single operator, including Akave, can silently rewrite the record. Third, durability up to 11 nines, anchored in independently distributed infrastructure rather than a single vendor's assurance. Because the OpenSharing protocol is open, Akave can sit underneath it as the auditable provider. Unity Catalog governs who may access a shared model, agent, or dataset, and Akave proves what that asset is and where it came from. That pairing matters most exactly where OpenSharing aims: regulated industries and cross-border exchanges where "trust our platform's logs" is not an answer a CISO, an auditor, or an EU AI Act assessor will accept. For a closer look at how Akave handles AI and agentic workloads, the architecture documentation covers the storage-layer details. Govern with Unity Catalog. Prove it with Akave. The two are additive, and the agentic era needs both.
Looking ahead
Over the next 6 to 12 months, expect the conversation around shared AI assets to move from can we share this to can we prove what we shared. The forcing functions are already on the calendar: the currently binding EU AI Act high-risk enforcement date, the steady accumulation of agent-to-agent workflows that act without human review, and a regulatory drift toward treating data lineage as evidence rather than documentation. OpenSharing will accelerate cross-organizational AI exchange, which means it will also accelerate the moment enterprises discover that governed access and auditable integrity are different guarantees, and that they need both.
The open protocol is the right foundation. The auditable substrate is the layer that makes it trustworthy when the asset leaves home. Databricks proved the industry will choose open over locked-in. The next thing the industry will choose is provable over assumed. Start with the storage layer: free trial or explore the technical setup at docs.akave.xyz.
Sources
- Databricks, "Introducing OpenSharing: the Next Evolution of Delta Sharing for the Agentic Era," June 16, 2026. https://www.databricks.com/blog/introducing-opensharing-next-evolution-delta-sharing-agentic-era
- Databricks, "Announcing the Databricks Storage Ecosystem," June 16, 2026. https://www.databricks.com/blog/announcing-databricks-storage-ecosystem-governing-enterprise-data-estate-wherever-it-lives
- OpenSharing open-source project, Linux Foundation. https://opensharing.io/
- European Union, "Article 10: Data and Data Governance," EU AI Act. https://artificialintelligenceact.eu/article/10/
- European Union, "Article 99: Penalties," EU AI Act. https://artificialintelligenceact.eu/article/99/
- Databricks, "Apache Iceberg v3 in Public Preview on Databricks," June 2026. https://www.databricks.com/blog/next-era-open-lakehouse-apache-icebergtm-v3-public-preview-databricks
- Covington AI Watch, "EU Parliament Votes to Defer EU AI Act Obligations," June 2026. https://www.covingtonaiwatch.com/2025/04/eu-parliament-votes-to-defer-eu-ai-act-obligations-for-general-purpose-ai-models/