Deterministic by design

The single most important thing to understand about Ronja if you’ve been burned by AI tools that confidently state wrong numbers: the numbers come out of a real engine, and the figures Ronja writes about them are checked against it.

The guarantee — numbers are computed by an engine

When you ask Ronja a quantitative question, the language model’s job is to write text: a DuckDB SQL query or a Python program. That text is handed to a real compute engine, executed, and the result returned is the engine’s actual output.

Concretely: the agent’s query tool takes the SQL the agent wrote, runs it on DuckDB, and returns the engine’s real output — the actual rows the query produced. Its Python tool does the same: the result is taken verbatim from what the code evaluated to, not from anything the model asserted. The tables and charts in an answer are drawn straight from those results.

The figures she writes are checked

A reply is more than its tables and charts: Ronja also writes figures into it — a total or a share in a sentence, the key figures at the top of an answer, a number in a caveat. Those are written by the model, so on their own they could be misread or mistyped. That is why she writes each figure she takes from the query results and metrics she read for this reply together with the calculation behind it, and the calculation is recomputed from those results as the reply arrives — Ronja either works the figure out from the calculation alone, or checks the figure she wrote against it. A figure that doesn’t match is shown with the recomputed value instead of hers and flagged as corrected; one that can’t be recomputed, or whose reading the results can’t settle, is flagged as not verified rather than guessed at. In a conversation with Ronja, she then adds a short correction at the end of her reply naming those figures. Nothing already on screen is rewritten.

You can see which figures were checked: they are underlined, and hovering one shows what it was computed from (see Checked numbers). A figure without the underline was not checked this way — for example a figure from an earlier reply, a note or your own message. A flagged underline is not a checked figure either: its card says why. Treat both as you would any statement: the queries behind the answer are there to check them against.

Every one of those executions is recorded. A run is written as an exec_runs telemetry record: a row is created before execution and stamped when it finishes, carrying query, AI-call, and token counters that are bumped from the running container’s own calls — the real work it did, not a number the model claimed. Because the query and the run are both recorded, every result is reproducible from the exact query that produced it.

This is the core difference from a chatbot that guesses figures. Ronja’s results come out of an engine you could re-run yourself, the figures she writes from them are recomputed and marked, and the trail to reproduce them is recorded.

The honest limit — correct execution isn’t correct interpretation

Here is the part that matters for trust, and that a serious evaluator will test: a query can execute perfectly and still answer the wrong question. The engine runs exactly what it was given — but the agent can pick the wrong column, the wrong filter, or the wrong interpretation of what you asked. Determinism guarantees the number is real; it does not guarantee the meaning is what you intended.

A real example. Analyzing a customer’s data, Ronja initially reached for a country column to break results out by geography — but that column didn’t exist; the geography lived in a column called market. It caught this by inspecting the schema before writing the query, and corrected. That’s the failure mode, and it’s genuine: this risk is mitigated, not eliminated.

How Ronja reduces interpretation risk

Ronja doesn’t claim the interpretation problem away — it puts guardrails around it and makes the residual risk auditable rather than hidden:

• Mandatory schema inspection. Before writing SQL, the agent has tools to see a table’s real columns, types, statistics, and most-frequent values — and it’s instructed to use them. The rule is explicit: verify that a table actually contains what you asked about before querying it.
• An explicit “list_price is not revenue” rule. The prompts name this exact class of mistake — a column whose name sounds like the thing you want but isn’t. The agent is told not to silently substitute a plausible-looking column for the real one.
• A plan or methodology gate before it computes. In Build mode, the agent writes a plan and waits for your go-ahead before creating anything. In Deep analysis, it pre-registers the question, its hypotheses, and its confirm-or-refute criteria — naming which tables and columns it will use — before it sees the numbers, so the analysis can’t drift into rationalizing whatever the data happened to show. In that mode, a well-justified “we can’t reliably answer this with the data” is treated as a success; manufacturing a confident answer the data can’t support is the one real failure.
• The queries, under the answer itself. Every laid-out answer carries a collapsed How this was computed holding the exact queries behind its numbers, and a Sources line naming the tables they read and when each was last refreshed. Checking a figure costs one click and doesn’t leave the conversation.
• End-to-end traces. Every execution also links to a full trace — the tree of steps, with per-step status, timing, and the SQL that ran against which tables. Where How this was computed shows the query behind one answer, the trace shows every step of the run that produced it.

The plan and methodology gates are covered in Standard, Deep analysis, and Build; the answer’s own sections are covered in Talking to Ronja, and traces in Monitor runs and traces.

The right mental model

Think of Ronja not as an oracle that emits truth, but as a sharp analyst colleague who shows their work and can be checked. The arithmetic behind a table, a chart or an underlined figure is real — computed by an engine, recorded, reproducible. The judgment about which arithmetic to do is subject to the same review any good analyst’s would be, and Ronja is built to make that review easy: it inspects the schema first, states its plan before it computes, and leaves a trace behind every number.

That honesty is the point. A promise that the model simply never makes mistakes collapses the first time an evaluator finds a misread column. “The numbers are computed and reproducible, and the interpretation is guardrailed and auditable” is a claim that holds up — which is exactly why it’s the one worth making.