From “Why” to “What Now”:How
CausalX, Databricks Lakebase,
and Ontos close the act loop on
the Lakehouse

CausalX is now an officially designated Databricks Brickbuilder Accelerator, and the first to operationalize causal AI on Databricks Lakebase, with Ontos providing the governed business catalog and knowledge-graph spine.
In our last blog, we wrote about how Databricks Genie closed the “explore” gap inside CausalX, letting any business user follow up on a causal finding in plain English, against governed data, without filing a ticket. We ended that post with a promise: Genie closed the explore gap; Lakebase, next, would close the act gap.
This is that blog.
Every enterprise dashboard answers the same question: what happened? CausalX answers why. Genie lets users explore the why. But until a finding becomes a logged decision, a triggered workflow, and a measurable outcome, causal intelligence is still just an analytics product. With Databricks Lakebase as the operational spine and Ontos as the governed business catalog and knowledge-graph layer, CausalX finally closes the loop: reason → explain → explore → act, all on one platform, all under Unity Catalog governance.
Causal first, AI second. Lakebase makes “act” first-class. Ontos makes “govern” first-class. CausalX makes the whole loop one product.
A quick refresher on what CausalX is
CausalX is a domain-agnostic causal intelligence product built natively on Databricks. It has been deployed across supply chain, financial services, energy, oil and gas, manufacturing, IT operations, healthcare, and customer experience use cases. The architecture is layered and deliberate, and the same pattern holds regardless of the industry:
Data Foundation
Bronze, Silver, and Gold delta tables conformed to a domain ontology. The ontology objects change with the use case (Customers, Accounts, Transactions for financial services; Wells, Pads, Lifts for upstream oil and gas; Assets, Work Orders, Crews for asset-heavy industries; Tickets, Services, Incidents for IT ops) but the layered shape does not.
Causal Engine
A deterministic, rule-pack driven engine that traverses ontology links from a KPI deviation back to its root cause, with a financial-impact figure attached to every finding. The rules are configurable per domain; the engine is not.
Agent Pool
Pre-built agents grouped into families per use case. Each agent owns one “why” question for one KPI and is wired to the ontology slice it needs.
Explanation Layer
A large language model wired in strictly as an explainer. It receives the structured causal findings and translates them into business prose. It is forbidden, by prompt and by design, from inventing causes that are not in the input.
Conversational Layer (Genie)
Natural-language exploration over the same Gold tables, scoped to the ontology slice the finding came from. The agent owns the why; Genie owns everything that comes after.
That is the product as it shipped through April 2026. Three things have changed since.
What changed: Lakebase, Ontos, and an official Brickbuilder badge
Three updates land together, and they are not coincidence; each unlocks the next:
1. CausalX is now an official Databricks Brickbuilder Accelerator.
Validated for the Databricks Data Intelligence Platform, packaged with reference architectures and sample data, and available through the Databricks partner ecosystem. Customers get from kickoff to a working causal use-case in weeks, not quarters.
2. Lakebase is now the operational spine of CausalX
Every recommended action, every approval, every counterfactual branch, every agent session, and every online feature read now runs through Lakebase, Postgres-compatible, sub-10 ms, zero-copy branchable, natively synced to Unity Catalog.
3. Ontos is the governed business-catalog and knowledge-graph layer.
We have moved our domain ontology and our “data-products-as-causal-findings” contract onto the Databricks Labs Ontos stack, which gives us ODCS data contracts, ODPS data-product packaging, an MCP server for AI assistants, and a semantic knowledge graph that ties technical Gold tables to business concepts.
The rest of this blog is what each of those means in practice, and what it unlocks across the industries CausalX is deployed in today.
Lakebase: from explore to act
A Lakehouse is a phenomenal substrate for analytical workloads. But the moment a CausalX agent says “the primary driver was X and the impact is $4.2M,” the conversation stops being analytical and starts being operational. Three things become urgent:
Branchable state
Counterfactuals are, by definition, the world that didn't happen. We need to spin up an isolated copy of operational state, replay a different intervention, measure the lift, and throw it away, hundreds of times a day, without polluting production.
Transactional decision logs
Every recommendation a CausalX agent makes is a decision a planner, an operator, a clinician, or a fraud analyst will act on. Those decisions must be written transactionally, indexed by entity, and joined back to the outcome, within milliseconds, not minutes.
Low-latency context for agents
Our Genie integration and our explainer cannot wait for a 30-second Delta scan to fetch “what is this customer's current intervention state” or “which open actions exist on this asset.”
Lakebase, Databricks' Postgres-compatible operational database with native lakehouse integration, zero-copy branching, and sub-10 ms reads, gives us exactly these three primitives, governed end-to-end by Unity Catalog. In the new CausalX architecture, Lakebase holds:
- • Recommended actions, approvals, and execution state: the table a user actually clicks on when they say “approve” in Genie. Every approval syncs bidirectionally to Delta for governed analytics and model-risk evidence.
- • Causal experiment branches: every do(X) simulation runs in a zero-copy Lakebase branch, isolated from production, scored, then discarded. What-if becomes a first-class operation, not a notebook exercise.
- • Decision and intervention logs: every causal finding, every override, every closed-loop outcome, written transactionally with a JSON evidence pointer back to the agent run that produced it.
- • Agent and session state: DAG selections, pinned KPIs, multi-turn conversation pointers, feedback loops. The chat thread becomes durable, not ephemeral.
- • Online feature reads: sub-10 ms lookups for live causal scoring inside customer-facing apps, embedded copilots, and the CausalX home screen.
Genie closed the explore gap. Lakebase closes the act gap. The chat thread is no longer the end of the workflow; it is the start of one.
Ontos: governance is no longer an afterthought
CausalX has always had an ontology. It is the thing that lets the engine traverse from “revenue dipped” to “which segment, which channel, which campaign.” Until now, that ontology was our own, a private artefact maintained in each deployment's Gold layer.
With this release, our ontology lives on Ontos, the Databricks Labs business catalog for Unity Catalog. That gives us four things we did not have before:
Data Products as a first-class contract.
Every CausalX agent family, every Gold fact table, every causal-findings stream is now packaged as an ODPS data product with explicit ownership, version, SLOs, and consumers. “Who owns the churn ontology slice” stops being tribal knowledge.
Data Contracts via ODCS v3.1.
Schema, quality rules, semantic annotations, and freshness guarantees are declared, enforced, and auditable. Compliance teams stop asking “is this table still trustworthy” and start reading the contract.
Semantic Knowledge Graph
Ontos links technical Gold tables to business concepts via a knowledge graph, so a finding like “driver = upstream lift inefficiency on Pad-7” resolves cleanly to the asset, the work-order history, the SCADA channel, and the owning crew, without bespoke joins.
Native MCP exposure for agents
Ontos exposes the catalog and the graph via the Model Context Protocol, which means CausalX agents (and any other AI assistant in the customer’s environment) can reason over the ontology natively, not via a brittle prompt-engineered wrapper.
For deployments that need materialized graph reasoning, we layer in OntoBricks, the Databricks Labs sibling project that compiles ontologies (OWL/SHACL/FIBO/FHIR/IOF/CDISC) into a triple store on Lakebase Postgres, with SPARQL, Cypher, Spark SQL, GraphQL, and MCP query surfaces. The connection is not accidental: OntoBricks chose Lakebase for the same reason we did; it is the right place to keep operational graph state next to the lakehouse it was derived from.
Stack summary: Delta + Unity Catalog (source of truth) · Ontos (business catalog, data products, KG, MCP) · OntoBricks (materialized graph, when needed) · Lakebase (operational spine: actions, branches, sessions, online reads) · CausalX Engine + Agents + Explainer + Genie.
What this unlocks, by industry
Causality is a horizontal capability. The pain points it dissolves are vertical and very specific. The list below is not exhaustive; it is the set of deployments where CausalX on Lakebase + Ontos is either in pilot or live today.
Reliability KPIs like SAIDI, SAIFI, and CAIDI are notoriously hard to debug: was the outage caused by weather, asset age, vegetation, switching, or load? CausalX builds a DAG across SCADA, OMS, AMI, and weather feeds; Lakebase holds the per-circuit action log and live grid state; Ontos packages the reliability ontology as a governed data product the regulator can read. A grid planner can branch the network in Lakebase, simulate a redesign, and have a causal lift estimate in minutes, with the audit trail attached.
Upstream: production deferment, lift inefficiency, ESP failure causality, and well-to-pad attribution are all chain problems. CausalX traces the chain across PI/SCADA, well-test, and work-order data; Lakebase branches let an engineer ask “if we had pulled the choke 8% earlier on Well-23, what would yesterday’s deferment have been?” and get a defensible answer before the morning operations call. Downstream: refinery yield, energy intensity, and HSE incident causality follow the same loop, with Ontos enforcing the API/IOGP-aligned ontology across business units.
Yield loss on a complex line is rarely one cause; it is a chain. CausalX builds a DAG across hundreds of SCADA/MES tags; Lakebase keeps the per-batch intervention log and current asset state so engineers can ask, in plain English: “If we had held kiln temperature 4°C lower on shift 2, what would Friday’s yield have been?” The same loop powers OEE improvement, energy-per-unit reduction, predictive-quality programmes, and supplier-defect attribution.
The eternal retail question is “Did the promotion drive incremental sales, or did it just cannibalize next week?” CausalX on Lakebase lets a category manager branch the live planogram, simulate a do-intervention on price or placement, and read uplift estimates against synthetic controls, without disturbing the live promo engine. Out-of-stock root cause moves from gut to graph. Markdown decisions move from instinct to evidence. Trade-promo ROI moves from quarterly review to live dashboard.
Regulators increasingly demand causal, not just correlative, explanations behind credit, fraud, and AML decisions. CausalX writes a per-decision causal trace to Lakebase (factors, counterfactuals, confidence, alternative outcomes), retrievable in milliseconds for adverse-action notices, ECOA/FCRA compliance, and AML investigations. The same trace, synced to Unity Catalog and contract-checked by Ontos, becomes the model-risk evidence pack, one source, two audiences, zero re-engineering.
From clinical trials to commercial analytics to claims, the central problem is the missing counterfactual. CausalX uses Lakebase branches as synthetic-control sandboxes: clone the patient or member cohort, apply an alternative protocol or care-path in silico, and measure causal lift on adverse events, readmission, or efficacy. Supply-chain teams use the same primitive to trace cold-chain excursions to outcome, fast enough to recall a lot before it ships. Ontos enforces the CDISC/FHIR-aligned ontology end-to-end.
Last-click attribution has been wrong for fifteen years; everyone knows it, almost nobody fixes it. CausalX models true content and channel lift, logs every recommendation and outcome to Lakebase at watch-event latency, and lets editorial and ad-ops teams ask “what would viewership look like if we had not pushed Title X to the homepage?” and answer it inside a decision meeting, not at the next quarterly review. Subscriber-churn drivers become testable, not theoretical.
OTIF, fill-rate, and freight-cost variance are multi-cause by nature: forecast error, supplier lead-time, lane capacity, weather, exception handling. CausalX traverses the network ontology, attributes impact to each node, and writes the recommended re-routing or expedite action to Lakebase, where the TMS picks it up. Branching lets a planner stress-test a network redesign before it ships.
MTTR, incident recurrence, and change-failure rate are the SAIDI/SAIFI of the IT world. CausalX builds a service-graph ontology, isolates the real driver of each major incident, and logs the post-mortem decision to Lakebase, turning the post-mortem from a wiki page into a queryable history of what broke, why, and what was done. Genie lets an SRE ask the history in plain English; Lakebase makes the action loop closable from inside the same thread.
Churn, NPS, and contact-rate are causal problems disguised as KPIs. CausalX attributes churn to specific network, billing, or service interactions; Lakebase holds the retention-offer state per customer; Ontos governs the unified customer ontology across BSS/OSS/CRM. The recommended retention action lands in the next CSR’s screen, not in a quarterly report.
DNBs ship causal experiments at product-release velocity; public-sector teams must defend policy interventions under audit. Lakebase branching serves both: rapid what-if simulation on real operational data, with every branch, decision, and outcome auditable through Ontos contracts in Unity Catalog. “If we changed the eligibility threshold by 2%, how many citizens would lose access, and which?” becomes a five-minute question, not a five-month study. “If we throttle this onboarding step, what is the projected funnel impact?” becomes a branch, not a war room.
What we learned wiring Lakebase and Ontos in
A few honest observations from the build, useful regardless of the industry you are deploying into:
For enterprise procurement this matters directly. When a security team asks whether data leaves the environment, the answer is no; not as a policy claim, but as an architectural fact. Unity Catalog governs everything inside the workspace. There is no second perimeter to audit, no external endpoint to scope into a data processing agreement, no third-party vendor holding operational records.
Treat Lakebase as the operational truth, Delta as the analytical truth.
Bidirectional sync is the feature; pick one as the writer per entity class and stop arguing. Actions and session state write Lakebase-first. KPIs and facts write Delta-first.
Branches are not just for what-ifs
We started using Lakebase branches for counterfactuals. We now use them for safe upgrades, A/B agent rollouts, and giving every CausalX deployment a per-tenant sandbox. Zero-copy is the unlock.
Put the ontology under contract on day one
Adopting Ontos forced us to write ODCS contracts for the causal-findings table we had been quietly evolving for two years. Two findings per cohort, broken assumptions, real bugs, caught by the contract checker, not by a customer.
Expose the graph via MCP, not via prompts
The moment we put Ontos’ MCP server in front of our agents, the prompt size dropped, accuracy went up, and the LLM stopped inventing relationship names that did not exist in the ontology.
Keep the boundary clean
Genie reads. Lakebase writes. Ontos governs. The causal engine reasons. Each layer owns one job; the integration is where the value compounds.
Audit trail is still everything
Every Lakebase write carries the agent version, the finding ID, and the approving user. Every Genie answer surfaces its SQL. Every Ontos contract violation lands in a notification, not a silent log. “The LLM said so” is still not an answer.
What is next on the roadmap
Moving Eagle Eye IQ's operational layer to Lakebase, our V2 architecture, produced three measurable changes:
Closed-loop action approvals from Genie (Q3 2026, shipping)
A user asks Genie to show open recommended actions for a KPI, approves one in the chat, and the approval is written transactionally to Lakebase, which fires the downstream workflow (TMS, CRM, EAM, dispatch, ITSM, etc.). The Lakebase write is what makes this safe: every approval is durable, audited, and reversible.
Counterfactual branches as a service (Q3 2026)
Today, branches are spun up by the causal engine. Next, any user can ask Genie for a branch, run a what-if against live state, and either promote the result or discard it. Branching becomes a first-class user surface, not an engine internal.
Ontos-driven cross-industry agent packs (Q4 2026)
Because Ontos formalises the data-product contract, we can ship pre-validated agent packs (energy, oil & gas, manufacturing, banking, life sciences, retail, telecom, public sector) that snap onto a customer's Unity Catalog in hours, not weeks.
OntoBricks-backed graph reasoning for compliance (Q4 2026)
For regulated industries, materialising the ontology into an OntoBricks triple store on Lakebase lets us run OWL/SHACL reasoning over policy and entitlement rules, turning compliance checks into graph queries, not custom code.
Cross-deployment causal pattern library (Q1 2027)
Across pilot deployments, certain causal patterns repeat across industries: supplier-induced quality drift, demand-cannibalisation, asset-aging cascades, churn-via-billing. We are packaging these as cross-industry pattern templates seeded into every new deployment.
The CXM thesis, completed
The Causal Experience Manager (CXM) thesis has always been: causal intelligence becomes a manager, not a dashboard, not a model, not a chatbot, when it can reason, explain, explore, and act in one continuous loop.
- • The Engine + Agents reason.
- • The Explainer explains, grounded only in what the engine produced.
- • Genie lets users explore the why in plain English.
- • Lakebase lets users act, with branching for what-if and transactional logs for accountability.
- • Ontos governs all of the above through data products, contracts, knowledge graphs, and MCP.
That is what Brickbuilder customers get on day one now, not a model, not a chatbot, not a dashboard. A loop. The same loop, whether the use case is grid reliability, refinery yield, claim adjudication, retail promo, or citizen-service eligibility.
A year ago, asking “why” required a data team. Six months ago, asking “what next” required a workflow team. Today, both are a sentence in a chat thread, with the audit trail attached. That is the shift the Brickbuilder accelerator is built around.
CausalX does not replace the data team. It gives every leader the first ten minutes back, and now, the next ten as well.
Want to know how CausalX can work for your enterprise?
Reach out at enterprisesales@celebaltech.com.





