Why Rexfin's Numbers Come From an Engine, Never From an AI Guess

Ask a language model to compute next year’s ending cash and it will give you a number. That number is a statistically plausible guess shaped like an answer, not a calculation: the model never actually took your revenue, subtracted costs, and rolled the balance forward. Sometimes the guess is close. Sometimes it’s off by a margin that matters, and you cannot tell which just by looking at it, because a confident wrong answer reads identically to a confident right one. That’s the specific failure Rexfin’s modeling engine is built to make impossible: the AI never computes a financial number. An engine does.

Two jobs, kept strictly separate

Rexfin splits the work into reasoning and execution. Understanding a question (which driver to flex, by how much, over which periods) is reasoning, and AI is genuinely good at it. Computing the result of that change against a real model is execution, and it has to be deterministic. So when someone asks “what if this customer churns,” the AI translates that into a driver change; a calculation engine recomputes the three statements against it; the AI narrates what came back. It never invents the cash figure itself.

The engine works from a dependency graph: every line (revenue, gross profit, retained earnings, closing cash) is a node with formulas pointing to the inputs it depends on. Change one driver and only the cells downstream of it recompute, in the right order, every time. Actuals (the figures seeded from a filing) are read-only; nothing in the engine can overwrite them, and nothing marked “modelled” can pretend to be sourced. That separation is what lets Rexfin label every cell honestly as actual or computed, an idea covered in more depth in the canonical atom store.

The identities have to actually hold

After every recompute, the engine checks that assets equal liabilities plus equity, that cash flow ties to the balance sheet, that the numbers reconcile within a tolerance that scales with the size of the figures rather than a fixed dollar amount that would false-fail on a rounded IFRS statement. This tie-out check runs on every single recompute, not as a spot check, and it’s what a downstream verification step promotes into a hard block on export if it fails, described in how verification works. A model that only looks balanced isn’t good enough; it has to actually reconcile.

Same inputs, same answer, every time

The engine’s determinism contract is specific: given the same actuals and the same driver values, it produces byte-identical output across runs and machines, with no clock, no randomness, and no network or model call anywhere inside the calculation path. That’s not a nicety: it’s the precondition for everything downstream. A verifier can’t meaningfully bless a number that might come out differently on a re-run, and a board can’t trust a scenario that isn’t reproducible from the assumptions that produced it.

This is also why scenarios in Rexfin are cheap to trust: a “downside” scenario is stored as sparse driver overrides on the base model, and each one runs through the identical engine and gets its own reconciliation check. Stack three assumptions in a board meeting and the numbers still tie out, because every one was computed the same way against the same foundation.

Where the engine refuses rather than guesses

Valuation outputs (NPV, enterprise value, IRR) are derived from the model’s own projected cash flows, never typed in separately, so an EV figure in a board pack traces back through the DCF math to the actual forecast. And where the math genuinely has no answer (an IRR with no sign change in the cash flows, a goal-seek target outside any reachable range), the engine returns a typed “not defined” or “no solution,” bounded by a fixed iteration cap, rather than a number dressed up as precise. That’s the same discipline running throughout: a bounded, honest failure beats a confident, fabricated one.

What this changes in practice

Once the arithmetic lives entirely in the engine, speed stops being dangerous. You can ask follow-up what-ifs live and trust the answer is a recomputation, not a fresh guess. Deterministic doesn’t mean the underlying logic is automatically correct: a wrong driver relationship still produces a wrong number, reliably. It means the wrong number can be found, traced, and fixed, which you cannot do with a figure an AI pulled from nowhere. It’s also the foundation the platform’s answer audit log and calibration and trust tuning build on: you can only calibrate confidence in an answer if the underlying number was actually computed, not generated.

For the rest of how Rexfin is built to be defensible end to end, see the Inside the Rexfin platform hub.