Enterprise AI Reasoning Architecture

What EARA does

Every query passes through seven stages. Each stage produces a typed artifact. Nothing is inferred; everything is traceable.

01 Parse. The LLM reads the question and extracts a formal evidence set.
02 Route. The evidence set is matched to the right domain model.
03 Identify. The causal query type is determined: observational, interventional, or counterfactual.
04 Compose. Sub-models are assembled into the query scope.
05 Execute. The causal model runs inference and returns a probability distribution.
06 Audit. The full reasoning chain is packaged into a DecisionCertificate.
07 Narrate. The LLM translates the certificate into plain English for the operator.

The LLM touches only the two ends: Parse and Narrate. Everything between runs on typed artifacts and deterministic algorithms.

Operations →

Add the one thing your LLM is missing: the ability to reason about your business.

For an Executive Reader

If your experts can explain how something works, we can turn that into a model your LLM can reason with, not just talk about. That’s EARA: the architecture, not a data science project.

Executive Summary

Your LLM talks fluently but doesn’t reason about your business. That knowledge lives in your experts, not your data. We build the causal model that gets it out and connects it to the AI you already run. It’s a real moat: everyone rents the same LLM, nobody else has your model. Twelve industries already have a starting point, so it doesn’t begin from scratch. The commitment starts small: one decision, one model. And the underlying method is real, published research, not a black box.

Twenty-five years across insurance, banking, energy, healthcare, cybersecurity, supply chain, and public sector. Every engagement, the same pattern: the knowledge that would have made the model work was sitting in the room, not in the data. The world is now spending billions to automate that same mistake (poor Watson).

A causal model

A simple Bayesian network: A and B cause C, B also causes D, C and D cause E
A and B cause (to some degree) C; B also causes D; C and D cause E.

01 Add Cognition →

Drop in how your experts reason, and your AI can reason too.

The missing piece is a causal model, a cause-and-effect map of your domain, built from your experts’ knowledge, that gives your LLM something to reason with.

LLM alone predicts. LLM plus causal AI understands, reasons, and provides reliable answers.

Built from your experts’ knowledge, not scraped from the web. Your people ask; the model reasons; your LLM translates.

Understands WHY
Understands
WHY
Identifies the causal drivers behind any outcome, separating what caused it from what merely accompanied it.
Answers WHAT IF
Answers
WHAT IF
Computes the effect of interventions before you make them, with named assumptions and a probability distribution over outcomes.
Explains HOW
Explains
HOW
Traces the reasoning path from evidence to conclusion, node by node, so every answer is inspectable and correctable.
Provides Reliable, Auditable Answers
Provides
RELIABLE, AUDITABLE ANSWERS
Every conclusion carries a certificate: the estimand, the evidence, the model version, and the rung at which it ran.

Together, these four properties close a loop that most AI deployments leave open: expert knowledge goes in, auditable answers come out, corrections go back in. The organisation gets smarter with every decision.

How seven reasoning services turn one causal model into answers for seven different classes of question.

The reasoning layer →

Probability answers one question. Four more require actual causal reasoning to answer at all.

Decision intelligence →

Example. Your strategy team asks: if we enter this market, what is the expected return, and what is the chance we lose money? Your LLM says it depends. This one lays out three options with expected NPV and loss probability for each, with the assumptions named, the reasoning shown, and a certificate your board can contest. See the model →

02 The Limits

Seven structural failures. None fixable by prompt engineering.

Large language models are powerful but structurally limited. The limits are not bugs. They are inherent in their architecture. These matter for high-stakes decisions.

  1. Trained on everyone else’s data: not yours.
  2. Frequency-based: they hallucinate where data is thin.
  3. Pattern-matching only: association masquerading as causation.
  4. Black boxes: no reasoning trail, no audit path.
  5. Static: blind to regime change.
  6. Optimised for the average: your needs are not average.
  7. No mechanism: predict outcomes but cannot tell you why.

Six specific reasons fluent output isn’t the same thing as reasoning about your business.

LLMs fail their users →

A model whose parameters can’t be read is a model whose assumptions can’t be contested.

Black boxes suck →

It estimates an association. It can’t tell you what would happen if you intervened, or what would have been different.

Regression: simple method, simple answers →

03 Your Moat

Everyone rents the same LLM. Only you can own a model of your domain.

You and your competitors are renting the same LLMs. But a model of your domain isn’t something you can rent. It encodes what your experts know, and no competitor can extract it from a training set.

Your domain models compound in ability. Each engagement deepens the library. The next model costs less than the first and answers more than the last.

Every answer is auditable: named assumptions, traceable reasoning, a certificate your regulators can inspect. When a regulator challenges the decision, the reasoning is there. When an expert finds an error, they can trace it to its assumption and correct it. The same property that satisfies your regulator makes your organisation smarter.

This year's AI layoffs are a bet that a vendor's model can replace a domain expert, indefinitely, at whatever price and quality that vendor sets going forward. A domain model is the opposite bet. It doesn't replace the expert. It keeps what they know, owned, auditable, and running regardless of what any single LLM vendor does next. Read the argument →

Every competitor has the same LLM. None of them has your domain model.

Reasoning infrastructure →

04 The Pitch

Pre-built models, calibrated to your organisation. You own the result.

Rung3 maintains a library of pre-built causal models across domains. Your subject-matter experts and I calibrate them to your organization: your data, your decisions, your edge cases. Four to eight weeks later, you own the result: a documented, auditable reasoning infrastructure queryable by any LLM you already run via a Python, R, or C API. Running on your servers. Under your governance. No vendor in the loop. No report. No deck. No dependency.

What you get is a .bayes model and the code layer that operates on it, seven reasoning primitives executable via Python, R, or C API. The LLM asks the questions. The code computes the answers.

What you get →

What you get

Two deliverables, not one.

The model. A .bayes file, your domain’s causal structure, encoded from your experts, with documented assumptions, versioned, and inspectable. This is the intellectual asset.

The code layer. Seven reasoning primitives implemented as API calls against the model, in Python, R, or C. Each answers a specific class of enterprise question:

  1. Explain: Why is this outcome occurring?
  2. Inquire: What evidence is worth collecting?
  3. Monitor: Has the world changed?
  4. Optimize: What should we do?
  5. Scenario: What would happen under each option?
  6. Robustness: How sensitive is the answer?
  7. Learn: What should the model update?

The LLM asks the questions in plain English. The code computes the answers against the causal model. Nothing in between is guesswork.

Four-step pitch flow: Model Library, Expert Calibration, You Own It, EARA Deployed.

05 Example Plug-ins

Twelve domains. Each model ready to calibrate and deploy.

Some from our library of domain plug-ins. Each one can be calibrated to your organisation, owned outright, and deployed on your infrastructure, not ours.

01 Strategy → 02 Finance → 03 Insurance → 04 Healthcare → 05 Marketing Mix → 06 Supply Chain → 07 Compliance → 08 Utilities → 09 Manufacturing → 10 InfoSec → 11 Litigation → 12 Canonical →

07 The Foundations

Pearl’s Ladder, Bayesian networks, structural causal models: established science.

The architecture rests on established theory: Pearl’s Ladder of Causation, Bayesian networks, and structural causal models. These are peer-reviewed, decades-tested techniques, named in Gartner’s Hype Cycle for AI.

The theoretical foundations →

06 One Decision

Don’t schedule a demo. Send me the decision your team is stuck on.

Don’t schedule a demo. Send me the decision your team is stuck on. I’ll tell you in half a day whether a causal model can answer it, and what the answer is.

Marc Vandenplas  ·  info@rung3.ai

San Francisco  ·  rung3.ai

Why LLMs fail their business users

Large language models are powerful but structurally limited. The limits are not bugs. They are inherent in their architecture. These matter for high-stakes decisions.

  1. Trained on everyone else’s data, not yours.
    The large models know the category: your industry’s averages, your competitors’ published playbooks, the public record of how businesses like yours have failed. They do not know your underwriting rules, your supplier relationships, your clinical protocols, your risk appetite. None of that is in any training set. It lives in the heads of the people who built your business.
  2. Frequency-based: they hallucinate where data is thin.
    LLMs learn from count. Rare claims, novel risks, edge cases the market has never seen at scale. The model confabulates from adjacent patterns. A causal model encodes the mechanism, not the count. An expert who has seen one wildfire liability case can build a model that reasons about the next one. A neural network that has seen ten cannot.
  3. Pattern-matching only: association masquerading as causation.
    LLMs operate by pattern-matching over observed co-occurrences. They can tell you what happened. They cannot tell you what would happen if you intervened, or what would have happened if you hadn’t. Every answer is a conditional, P(Y|X), dressed up as an explanation. The moment a business question requires “what if we do X” or “what caused this outcome,” the LLM is working outside its architecture. It will answer. The answer will be plausible. It will not be right in the way that matters for a decision.
  4. Black boxes: no reasoning trail, no audit path.
    An LLM cannot show its work in any meaningful sense. It produces an answer with no contestable basis: no named assumptions, no traceable inference steps, no audit trail for regulators or internal review. When the decision is challenged, there is nothing to inspect.
  5. Static: blind to regime change.
    LLMs are trained once and frozen. They do not know the world has shifted: new regulation, new market structure, new risk profile. A causal model can detect when its parameters are drifting and flag the divergence. An LLM cannot.
  6. Optimised for the average: your needs are not average.
    LLMs minimise error across a population. Your needs are specific: this claim, this patient, this supplier, this market entry. Optimising for the average gives you the wrong answer for the specific case more often than it should, and gives it confidently.
  7. No mechanism: predict outcomes but cannot tell you why.
    Without a model of mechanism, you cannot intervene correctly. Knowing that X predicts Y does not tell you whether changing X will change Y, or whether both are driven by a third factor you have not seen. Mechanism is what separates a decision-support system from a very fluent search engine.

Cognition

Cognition is the compound capability that emerges when an LLM's linguistic intelligence is paired with a Bayesian causal model's structural knowledge. Neither component is sufficient alone.

The LLM handles language: parsing intent, retrieving associations, generating fluent output, but it operates at too basic a level: pattern matching over observed co-occurrences. It cannot reason about interventions or counterfactuals because it has no model of mechanism. The Bayesian network supplies that mechanism: variables, dependencies, causal structure. It adds what language models cannot: principled handling of uncertainty, graceful inference when data is missing or partial, and probability distributions over outcomes rather than point predictions. Neither component can converse, interpret ambiguous inputs, or explain results in plain language without the other.

The combination clears the bar for genuine decision-support cognition: the system receives a question in natural language, selects the appropriate domain plug-in, executes the causal query against it, and returns an answer grounded in mechanism rather than correlation.

Cognition = language understanding × causal reasoning. Either factor zeroed out collapses the product, though “×” is a simplification; see why “×” is the wrong operator.

When a client asks "what would have happened if we hadn't launched that campaign," that's a question no LLM alone can answer reliably. The domain plug-in reasons over the case and returns a defensible answer.

How EARA works

LLM alone predicts. LLM plus causal AI understands, reasons, and provides reliable answers.
What EARA adds.
Four-step process: Model Library, Expert Calibration, You Own It, EARA Deployed.
How you get there.