A16Z NEWS / OCTOBER 27, 2026 / Ben Horowitz & Michael McGuiness
Databricks × OpenLink: a coopetitive meshup of shared meaning, governed action, and portable memory
Notes and analysis on “Databricks & the Future of the Firm,” with a proposed OpenLink portfolio architecture. Documented capabilities and proposed integrations are distinguished throughout.
The article makes the firm’s shared record central to autonomous work. This meshup asks how that record can remain useful across databases, agents, and models. Databricks offers an integrated data-and-agent environment. Virtuoso, with its OpenLink AI Layer (OPAL) and agent-rdf-memory modules, complemented by Universal Data Access (UDA), offers a loosely coupled route. Their overlap creates competition, while standard interfaces create room for cooperation. Durable advantage depends on preserving business meaning, permissions, evidence, and evaluated decisions.
The following comparison is a capability map, without winner scores or implied feature equivalence. OPAL and agent-rdf-memory are included within the Virtuoso position.
| Dimension | Databricks platformIntegrated data and AI platform | VirtuosoMulti-model data server + OPAL and agent-rdf-memory modules |
|---|---|---|
| What is true?Operational and analytical state | Lakehouse and Lakebase are the article’s foundation for analytical and transactional state. Lakebase adds branch-based development and testing. | Virtuoso combines local Structured Query Language (SQL) and Resource Description Framework (RDF) data with attached relational sources. UDA supplies applicable drivers and bridges; source systems can retain their operational role. |
| What does it mean?Business meaning and authority | Genie Ontology combines curated semantics with inferred snippets and authority scoring; it respects source permissions. The inspected documentation labels it Public Preview. | Virtuoso uses explicit RDF identities, ontologies, Linked Data Views, and configured inference. agent-rdf-memory makes selected operational definitions and rules queryable. |
| What is allowed?Identity and runtime authorization | Unity Gateway centralizes AI service governance, including access and cost controls. Unity Catalog permissions constrain the context available to Genie. | Configured Virtuoso Authentication Layer (VAL) policies and data-source permissions enforce access. OPAL calls operate within those rights; memory instructions describe intended behavior. |
| Did it work?Evaluation and retained outcomes | The article describes task-specific exams, feedback, and Agent Bricks optimization. Databricks’ reported Genie benchmark has a bounded internal test suite. | OPAL sessions and RDF provenance can preserve actions, evidence, outcomes, and corrections. A task-specific evaluation process must be designed; storage alone supplies no accuracy guarantee. |
| How do people act?Natural language and tool use | Genie offers natural-language access, shareable agents, external knowledge connectors, and Model Context Protocol (MCP) integration; developers can build more customized agents through Agent Bricks. | Virtuoso with OPAL provides natural-language interaction with data spaces and declared tools. Agent memory retrieves relevant context rather than requiring every rule in each prompt. |
| What survives a model change?Portable knowledge and operational binding | The article argues that firm-owned definitions, permissions, and evaluated experience should survive model replacement; open foundations support this ambition. | RDF memory, explicit identifiers, declarative queries, and standard interfaces can preserve context across agents and models. An exported graph still needs a compatible runtime and access policies. |
| How is experimentation isolated?Database isolation versus semantic scope | Lakebase documents database branches that isolate development and test changes. | RDF named graphs partition semantic content; they are not a claim of Lakebase-style database branching. Use configured transactions, copies, or separate environments for isolated writes. |
| Where can they cooperate?A proposed integration boundary | Databricks SQL exposes an authenticated Java Database Connectivity (JDBC) connection that a compatible client can use. | The live showcase attaches Databricks bakehouse tables, exposes an RDF View, and provides SQL, SPARQL inside SQL (SPASQL), and SPARQL examples over the same business data. UDA drivers and bridges supply applicable connectivity paths across the wider portfolio. |
The article links the data architecture of an enterprise with the shape of work and management. These are the authors’ arguments, rather than established organizational forecasts.
The authors expect more workers to specify outcomes, delegate execution, and judge results. Their account retains human attention for people development, ethical judgment, and unfamiliar situations.
The article’s strongest portability test is whether a replacement model can inherit the firm’s definitions, permissions, evaluated cases, and exceptions. The proposed moat is a learning loop that improves decisions.
This is a favorable thesis written from an investor’s perspective: the article describes a16z’s financing relationship with Databricks. Company growth figures, autonomy forecasts, and organizational effects remain attributed claims.
Drawing on Ronald Coase and Herbert Simon, the article argues that shared records can reduce coordination costs inside and outside a firm. The result need not be uniformly larger or smaller companies; a wider range of organizations can become feasible.
The article presents four successive technology curves as the foundation for a new operating model. This is its architectural history, summarized without using revenue or activity figures as technical proof.
The source starts with Spark’s reuse of data in memory between computational rounds, addressing the disk-heavy iteration pattern of early Hadoop workloads.
Table layers over lake files bring reliability, schema management, and version history to storage used by analytical and machine-learning workloads.
The article connects the Neon acquisition and Lakebase with separating compute from storage and making isolated database branches practical for experimentation.
Genie and Agent Bricks sit above the data foundation. The article’s System of Record for Agents adds meaning, authority, and evaluation to shared state.
Virtuoso supplies the data substrate. Its modules add an AI harness and queryable operational memory; UDA complements them with connectivity. This mapping is our synthesis of the documented capabilities.
UDA supplies standards-based drivers and bridges. Virtuoso can attach reachable relational tables and query them alongside local data; a warehouse migration is not a prerequisite for every semantic use case.
The OPAL module gives Virtuoso a natural-language agent interface and tool integration. It supports Model Context Protocol (MCP), Agent-to-Agent (A2A), and OpenAPI interfaces, while models and data spaces remain loosely coupled.
Configure a Virtuoso instance as the store for agent-rdf-memory and bind the agent through AGENTS.md. Intent selection retrieves the relevant preferences, how-tos, and session context. Files remain an explicit fallback when endpoint retrieval is unavailable or incomplete.
Explore existing showcases on demo.openlinksw.com: the same enterprise records can serve SQL tools, graph queries, and an agent harness. SPASQL places a SPARQL query inside SQL so its results behave like an ordinary derived table.
Analyze revenue by city over the attached bakehouse tables. SQL joins the source tables, SPASQL wraps a query over their RDF View, and SPARQL follows transaction-to-franchise links. These examples make the cooperative data-access path concrete.
Read PostgreSQL clients through SQL, then inspect the generated entity types through SPASQL or SPARQL. Record hyperlinks and ontology terms let the same operational data participate in a wider semantic layer.
Ask for people using the shared Friend of a Friend (FOAF) vocabulary. The query follows generated classes to foaf:Person and returns employees from CSV files and native Virtuoso SQL tables in one result.
Join SQL Server customers, MySQL orders, and native Virtuoso products through one SQL statement. The Northwind graph example shows the complementary route: aggregate sales by following links among order lines, products, and categories.
The two approaches compete for the agent’s trusted working context. They can also form a composed architecture when the enterprise wants Databricks workloads and cross-system semantic context together.
Both routes address natural-language work over enterprise context. Evaluate the assembled experience: semantic coverage, permitted actions, retained evidence, evaluation quality, and the effort required to maintain them. A feature inventory alone cannot decide which fits.
Keep suitable workloads in Databricks. The existing bakehouse showcase demonstrates relational attachment and an RDF View in Virtuoso. OPAL can use declared query tools over this semantic layer; add the organization’s memory, action policies, and evaluation cases around that data-access path.
Database credentials and source permissions must govern the attached data. Review which columns and relationships mappings expose, and enforce the resulting graph/service permissions in Virtuoso. A permission rule in memory must not be mistaken for an enforcement point.
Genie’s authority-ranked context is not automatically equivalent to RDF and Web Ontology Language (OWL) entailment. Named graphs are not database branches. Portability of context is not automatic portability of executable workflows. These distinctions keep the integration design testable.
A bounded invoice-exception review loop connects retrieved business definitions, authorized queries, human review, and reusable corrections.
For a request to explain an invoice exception, classify the intent and retrieve the governing definition, source-priority rule, approved procedure, and relevant prior cases. Select context by its task relationship rather than loading the entire memory corpus.
OPAL can invoke declared SQL or SPARQL Protocol and RDF Query Language (SPARQL) tools over permitted data. Virtuoso can join an attached invoice view with stored customer and policy descriptions. The memory rule guides the request; source and runtime authorization govern the query.
Return the evidence and proposed resolution to the responsible person when the workflow requires approval. An agent’s remembered preference does not authorize a credit note, payment, or change to the financial record.
Record the cited facts, policy version, proposed action, reviewer correction, and observed outcome with named identifiers. A later agent can retrieve the applicable lesson. Retention, access, and review policies determine what belongs in shared memory.
Retain the selected query, its target graph or data source, the governing business definition, and the evaluation case in memory. A later agent can retrieve that procedure and repeat it with the same tools while applying the caller’s current access rights.
The article’s organizational thesis, product documentation, and our integration proposal answer different kinds of questions. Keep each conclusion attached to the evidence that supports it.
Databricks reports 84.5% first-attempt correctness for Genie on 28 enterprise data-analysis questions, versus 52.4% for its strongest anonymized general-purpose coding-agent comparison. This is an internal June 2026 result—not a Virtuoso comparison or a universal accuracy rate.
The article uses revenue run rates, agent activity volumes, and company valuation to illustrate commercial momentum. The runnable showcases let readers examine the architectural data-access capabilities directly.
The existing showcases expose concrete queries over Databricks, PostgreSQL, SQL Server, and native Virtuoso data. Follow the query text and linked records to inspect the data-access path, then use task-specific cases to evaluate the agent workflow built around it.
Export the definitions, context, cases, and evidence, then repeat a bounded task with a replacement model. Check whether source authority, access decisions, and evaluated outcomes remain intelligible. The result measures the assembled system rather than a portability slogan.
Specify the task, accountable owner, permitted actions, source systems, review threshold, and observable success criteria before connecting an agent.
Configure authenticated data-source access. Use UDA drivers or bridges where applicable; attach approved tables or views to Virtuoso. If Databricks is included, verify the selected JDBC path and its source permissions.
Generate Linked Data Views and their source ontology, assign stable row hyperlinks, and align relevant classes and properties with shared vocabularies. Preserve the source of each definition and its version.
Install OPAL as a Virtuoso VAD module. Configure the Virtuoso store for agent-rdf-memory and bind the agent through AGENTS.md. Register the allowed tools and the task’s context-retrieval policy.
Configure source permissions and Virtuoso/VAL access rules for the required services and graphs. Check both allowed and denied cases. Keep action approval requirements explicit in the workflow.
Run a bounded set of ordinary, conflicting, and exceptional cases. Inspect evidence citations and proposed actions as well as final answers. Retain reviewer corrections and outcomes using the organization’s retention rules.
Use the same definitions, evaluation cases, and authorized tools with another model. Compare outcomes and preserved context, then refine the procedure from the observed differences.
Interactive graph visualization derived from the companion RDF. Click nodes to resolve, drag to explore. Graph data embedded from companion RDF at generation time.
Choose a collection recipe or a live showcase query, inspect its text, and run it against the selected service.
Reproduced verbatim from the companion RDF. Execute loads the query into the workbench below and runs it live.
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX schema: <http://schema.org/>
SELECT ?claimIri ?claim ?status ?sourceIri
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-future-firm-openlink-meshup-gpt6-1.ttl> {
?claimIri rdf:type schema:Claim ; schema:name ?claim ;
schema:genre ?status ; schema:citation ?sourceIri .
}
}
ORDER BY ?status ?claimPREFIX schema: <http://schema.org/>
SELECT ?dimensionIri ?dimension ?offeringIri ?offering ?position
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-future-firm-openlink-meshup-gpt6-1.ttl> {
<https://www.a16z.news/p/databricks-and-the-future-of-the#four-questions> schema:hasPart ?dimensionIri .
?dimensionIri schema:name ?dimension ; schema:position ?order .
?cell schema:category ?dimensionIri ; schema:about ?offeringIri ;
schema:text ?position .
?offeringIri schema:name ?offering .
}
}
ORDER BY ?order ?offeringPREFIX schema: <http://schema.org/>
SELECT ?moduleIri ?module ?description
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-future-firm-openlink-meshup-gpt6-1.ttl> {
<http://dbpedia.org/resource/Virtuoso_Universal_Server> schema:hasPart ?moduleIri .
?moduleIri schema:name ?module ; schema:description ?description .
}
}
ORDER BY ?modulePREFIX schema: <http://schema.org/>
SELECT ?stepIri ?order ?step ?instruction
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-future-firm-openlink-meshup-gpt6-1.ttl> {
<https://www.a16z.news/p/databricks-and-the-future-of-the#workflow> schema:step ?stepIri .
?stepIri schema:position ?order ; schema:name ?step ; schema:text ?instruction .
}
}
ORDER BY ?orderPREFIX : <http://www.databricks.com/bakehouse#>
SELECT ?city
(COUNT(DISTINCT ?transaction) AS ?orders)
(SUM(?totalPrice) AS ?revenue)
FROM <http://demo.openlinksw.com/databricks-bakehouse-r2rml#>
WHERE {
?transaction a :Transaction ;
:franchise ?franchise ;
:totalPrice ?totalPrice .
?franchise :city ?city .
}
GROUP BY ?city
ORDER BY DESC(?revenue)
LIMIT 10PREFIX nw: <http://demo.openlinksw.com/schemas/Northwind/>
SELECT ?categoryName
(ROUND(SUM(?q * ?p * (1 - ?d))) AS ?totalSales)
(SUM(?q) AS ?units)
FROM <http://demo.openlinksw.com/Northwind#>
WHERE {
?od a nw:Order_Details ;
nw:quantity ?q ; nw:unitprice ?p ; nw:discount ?d ;
nw:has_products ?product .
?product nw:has_categories ?cat .
?cat nw:categoryname ?categoryName .
}
GROUP BY ?categoryName
ORDER BY DESC(?totalSales)PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?source ?generatedClass (COUNT(DISTINCT ?person) AS ?people) (SAMPLE(?person) AS ?example)
WHERE {
?generatedClass rdfs:subClassOf foaf:Person .
{ GRAPH <urn:demo.csv:northwind:data> { ?person a ?generatedClass } BIND("CSV files" AS ?source) }
UNION
{ GRAPH <http://demo.openlinksw.com/Northwind#> { ?person a ?generatedClass } BIND("Virtuoso SQL tables (Demo.demo)" AS ?source) }
}
GROUP BY ?source ?generatedClass
ORDER BY ?sourceSELECT ?type (COUNT(?s) AS ?n)
FROM <http://demo.openlinksw.com/postgres_postgres_jdbc_mt_codex_20260403#>
WHERE { ?s a ?type }
GROUP BY ?type
ORDER BY DESC(?n)A join and an aggregate over two attached Databricks tables. The SPARQL card "Revenue by city" below returns the same numbers through the RDF View.
SELECT TOP 10 f.city, COUNT(*) AS orders, SUM(t.totalPrice) AS revenue
FROM databricks.bakehouse.sales_transactions t
JOIN databricks.bakehouse.sales_franchises f ON t.franchiseID = f.franchiseID
GROUP BY f.city
ORDER BY 3 DESCThe Databricks RDF View, aggregated in SPARQL and handed back to SQL as rows.
SELECT city, orders, revenue
FROM (
SPARQL
PREFIX : <http://www.databricks.com/bakehouse#>
SELECT ?city
(COUNT(DISTINCT ?transaction) AS ?orders)
(SUM(?totalPrice) AS ?revenue)
FROM <http://demo.openlinksw.com/databricks-bakehouse-r2rml#>
WHERE {
?transaction a :Transaction ;
:franchise ?franchise ;
:totalPrice ?totalPrice .
?franchise :city ?city .
}
GROUP BY ?city
ORDER BY DESC(?revenue)
LIMIT 10
) AS xThe attached PostgreSQL table, read through Virtuoso over XMLA without moving the data.
SELECT TOP 10 clientid, clientname, clientgender, clientcountryid FROM "postgres"."postgres_jdbc_mt"."clients"The PostgreSQL RDF View profiled by type and returned to SQL as rows.
SELECT type, n
FROM (
SPARQL
SELECT ?type (COUNT(?s) AS ?n)
FROM <http://demo.openlinksw.com/postgres_postgres_jdbc_mt_codex_20260403#>
WHERE { ?s a ?type }
GROUP BY ?type
ORDER BY DESC(?n)
) AS xFrom the Decisive Knowledge post: customers in SQL Server, orders in MySQL and employees in Virtuoso, joined in one SQL statement. The button opens it with the demo account preset; the post's original link is beside it.
SELECT
A.CustomerID,
A.CompanyName,
B.OrderID,
C.EmployeeID,
C.LastName,
C.FirstName
FROM
"sqlserver"."northwind"."customers" A
NATURAL JOIN
"mysql5"."northwind"."orders" B
NATURAL JOIN
"Demo"."demo"."employees" C