A16Z NEWS / OCTOBER 27, 2026 / Ben Horowitz & Michael McGuiness

The firm that keeps what it learns

Databricks × OpenLink: a coopetitive meshup of shared meaning, governed action, and portable memory

8dimensions compared
KG curated by kg-generator, rdf-infographic-skill, and GPT-6 on behalf of Kingsley Idehen

Notes and analysis on “Databricks & the Future of the Firm,” with a proposed OpenLink portfolio architecture. Documented capabilities and proposed integrations are distinguished throughout.

Executive SummaryBy kg-generator

Synopsis

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.

View this analysis as a KG entity
CAPABILITY MAP

Four questions, two architectural routes

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.
Databricks platformIntegrated data and AI platform
Lakehouse and Lakebase are the article’s foundation for analytical and transactional state. Lakebase adds branch-based development and testing.
Genie Ontology combines curated semantics with inferred snippets and authority scoring; it respects source permissions. The inspected documentation labels it Public Preview.
Unity Gateway centralizes AI service governance, including access and cost controls. Unity Catalog permissions constrain the context available to Genie.
The article describes task-specific exams, feedback, and Agent Bricks optimization. Databricks’ reported Genie benchmark has a bounded internal test suite.
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.
The article argues that firm-owned definitions, permissions, and evaluated experience should survive model replacement; open foundations support this ambition.
Lakebase documents database branches that isolate development and test changes.
Databricks SQL exposes an authenticated Java Database Connectivity (JDBC) connection that a compatible client can use.
VirtuosoMulti-model data server + OPAL and agent-rdf-memory modules
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.
Virtuoso uses explicit RDF identities, ontologies, Linked Data Views, and configured inference. agent-rdf-memory makes selected operational definitions and rules queryable.
Configured Virtuoso Authentication Layer (VAL) policies and data-source permissions enforce access. OPAL calls operate within those rights; memory instructions describe intended behavior.
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.
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.
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.
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.
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.
Section 1

What the article contributes

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.

Shared state can support distributed action

A common record can let people and agents coordinate without sending every question through a hierarchy. The article distinguishes changing information flow from eliminating the human org chart.

Execution becomes cheaper; judgment still matters

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.

Learning should survive the next model

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.

Read the investment context

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.

Lower coordination costs can change firm boundaries

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.

Section 2

From Spark to agents

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.

1

Spark — iterative computation

The source starts with Spark’s reuse of data in memory between computational rounds, addressing the disk-heavy iteration pattern of early Hadoop workloads.

2

Lakehouse — a shared analytical foundation

Table layers over lake files bring reliability, schema management, and version history to storage used by analytical and machine-learning workloads.

3

Lakebase — operational databases for agent work

The article connects the Neon acquisition and Lakebase with separating compute from storage and making isolated database branches practical for experimentation.

4

Agents — turn shared context into work

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.

Section 4

See the data work across interfaces

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.

Databricks logoDatabricks: three interfaces, one business question

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.

PostgreSQL logoPostgreSQL: from records to entities

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.

OpenLink logoOne vocabulary across different sources

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.

OpenLink logoSQL federation and graph analytics

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.

Section 6

Compete on experience; cooperate through interfaces

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.

The competitive overlap

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.

The complementary route

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.

Preserve the policy boundary

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.

Keep the useful differences visible

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.

Section 7

Agent-rdf-memory in use

A bounded invoice-exception review loop connects retrieved business definitions, authorized queries, human review, and reusable corrections.

Retrieve the relevant contract

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.

Query evidence under the caller’s rights

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.

Separate a proposal from an authorized action

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.

Retain the correction and its scope

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 a runnable procedure

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.

Section 8

Read the evidence at its actual scale

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.

A bounded vendor benchmark

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.

Market figures are article claims

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.

Follow the data-access path

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.

Test sovereignty by replacement

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.

How-To

Build a bounded, portable learning loop

1

Choose one bounded decision

Specify the task, accountable owner, permitted actions, source systems, review threshold, and observable success criteria before connecting an agent.

2

Connect approved data

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.

3

Publish shared business meaning

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.

4

Install the harness and bind memory

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.

5

Enforce access at the runtime boundary

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.

6

Evaluate with representative cases

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.

7

Replace the model and repeat

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.

FAQ

Frequently asked questions

What is the central coopetitive thesis?▼
Is OPAL the same thing as Genie?▼
Are OPAL and agent-rdf-memory separate platforms beside Virtuoso?▼
What does UDA contribute?▼
Must all enterprise data move into one database?▼
Does an RDF memory rule enforce access permissions?▼
Is Genie Ontology equivalent to RDF reasoning?▼
Does the benchmark prove that one portfolio is better?▼
Can a named graph replace a Lakebase branch?▼
How does agent-rdf-memory make a query workflow repeatable?▼
What should survive a model change?▼
What would establish that the integration works?▼
Glossary

Core technical glossary

Knowledge Graph Explorer 221 nodes · 1084 links

Interactive graph visualization derived from the companion RDF. Click nodes to resolve, drag to explore. Graph data embedded from companion RDF at generation time.

The firm that keeps what it learns

Nodes: 0 Links: 0
Click SVG to activate zoom, click outside to release | Drag nodes to pin, double-click to unpin
Classes Properties Instances
SPARQL Workbench 11 query recipes

Choose a collection recipe or a live showcase query, inspect its text, and run it against the selected service.

Sample Queries

Reproduced verbatim from the companion RDF. Execute loads the query into the workbench below and runs it live.

Query 1 — Trace claims to their sources
SPARQL
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 ?claim
Query 2 — Compare the four questions and other dimensions
SPARQL
PREFIX 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 ?offering
Query 3 — Inspect the Virtuoso module relationship
SPARQL
PREFIX 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 ?module
Query 4 — Read the proposed workflow in order
SPARQL
PREFIX 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 ?order
Revenue by city
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
Sales by category
SPARQL
PREFIX 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)
One shared class, two different sources
SPARQL
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 ?source
Entity types in the PostgreSQL view
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)

Query editor

▶ Run live query SELECT: text/x-html+tr | DESCRIBE/CONSTRUCT: text/x-html-nice-turtle

SQL and SPASQL showcases

Revenue by city, in SQL · SQL

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.

SQL
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 DESC
Open SQL in Virtuoso Data Spaces
Revenue by city, SPARQL inside SQL · SPASQL

The Databricks RDF View, aggregated in SPARQL and handed back to SQL as rows.

SPASQL
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 x
Open SPASQL in Virtuoso Data Spaces
PostgreSQL clients, queried in place · SQL

The attached PostgreSQL table, read through Virtuoso over XMLA without moving the data.

SQL
SELECT TOP 10 clientid, clientname, clientgender, clientcountryid FROM "postgres"."postgres_jdbc_mt"."clients"
Open SQL in Virtuoso Data Spaces
Entity types, SPARQL inside SQL · SPASQL

The PostgreSQL RDF View profiled by type and returned to SQL as rows.

SPASQL
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 x
Open SPASQL in Virtuoso Data Spaces
Federated join: SQL Server + MySQL + Virtuoso · SQL

From 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.

SQL
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
Open SQL in Virtuoso Data Spaces