Asking the model questions — what-if, goal seek, sensitivity, explain
A model answers questions only once you stop editing it. Every tool on this page evaluates the model without writing anything: the committed numbers stay exactly as they are, and what you see is a hypothetical read. That is why the pane that hosts them says Hypothetical — nothing is saved.
All of them follow References and path lookups into every cube that depends on the one you started from, so a question asked in an Assumptions cube is answered in the P&L, the cash flow and the valuation.
From the grid
Right-click a cell. The bottom of the menu offers:
| Menu item | Question it answers | Needs |
|---|---|---|
| What if… | If this cell were X, what moves — here and in every cube that references this one? | Any cell |
| Goal Seek… | What must an input be for this cell to reach X? | A calculated cell |
| Sensitivity… | How does this cell move as one or two inputs sweep a range? | A calculated cell |
| Simulate… | What is the range of this cell when several inputs are uncertain at once? | A calculated cell |
| Explain… | Where does this number come from, which inputs actually drive it, and what does it feed? | Any cell |
Typing a value
Every number field in the pane takes what a grid cell takes: 1.5M, 2k,
0.5B and 1T, either separator convention (1 234,56 or 1,234.56),
a currency or percent sign, and parentheses for a negative. What the field
understood replaces what you typed when you leave it, so 1.5M becomes
1500000 in front of you rather than at evaluation time.
Values of 1 or more are kept to two decimals — a solved 1133.333333 reads as 1133.33. Anything below 1 keeps every digit you type, because a rate of 0.075 means something different from 0.08.
What if
Type a value and evaluate. The pane lists every cell whose value would change, cube by cube, with before, after and the delta. On an input cell the value replaces the input; on a calculated cell it pins the cell to that value (the formula is set aside for the run) so you can ask "if Revenue were 1.2M, what would the tax line be?" without knowing which inputs would produce it.
Goal seek
Enter the target value and pick the input to vary. The picker offers the cell's drivers first — the inputs Explain finds, ranked by how much they move this cell, in this cube, in a referenced cube, or in a data table — and then the input items of the formula's own dimension. The solver is exact in a few evaluations for linear models and reports one of:
- Solved — the input value and the impact of setting it.
- No effect — the target does not respond to that input; it is not a driver of this cell, so pick another.
- No solution within bounds / stopped at the limit — the closest point found is shown.
Sensitivity
Pick an input and a from / to / steps range (seeded at ±20% of the driver's current value), optionally a second input for a two-way table, and draw. Each cell of the table is one full evaluation of the reference chain, so keep grids modest — a 5 × 5 table is 25 evaluations.
Simulate
A sensitivity table moves one or two inputs along a line; Simulate moves several at once and shows the range of this cell. Pick each uncertain input and give it a distribution — uniform (min, max), normal (mean, sd) or triangular (min, mode, max), seeded around its current value at ±20% — set a run count (200 by default, up to 1,000) and simulate. Every run draws all the inputs together and evaluates the whole chain, so the result is this cell's mean, spread, 5th / 50th / 95th percentiles, a histogram coloured by side of today's value, and below today — the share of runs in which the cell came out lower than it is now, the plainest statement of risk a model can give. The draws are seeded, so running again gives the same answer.
Keeping a run. Under the result, editors get Keep this run: name it and it is stored, so you can come back to it, compare it with a run from a month later, or put it on a dashboard. Saving re-runs the same question with the same seed, so what is kept is exactly the run you are looking at — and it changes nothing in the model. A saved run is a reading, not a live figure: it does not update when an input moves, which is the point of keeping it. The dashboard widget prints the date for that reason, and so does the assistant.
Explain
Explain runs as soon as it opens and shows three things:
- Formula — the formula items at this cell, one per dimension that carries one.
- Reads — the operands with their current values. A cross-cube read is placed in the cube it reads from ("Profit × UK in P&L"); a table read is named by table, row and column.
- Drivers — every leaf input the formulas transitively read, each
nudged by 1% through the whole chain, with the resulting change and
elasticity (percent change of this cell per percent change of the
input). Shown as a tornado by default: one bar per input, drawn left
for a negative effect and right for a positive one, scaled to the largest,
so the ranking and the spread read at a glance; switch to Table for
the probe values. Reading a formula tells you what a number is made of;
the drivers tell you what it is sensitive to —
Margin = Profit / Revreads Revenue directly and again through Profit, and only the nudge shows that Cost moves the margin more than Revenue does. - Used by — the items this cell's items feed, across cubes: the structural answer to "what breaks if I change this?". This part works on input cells too, which is why Explain is offered on every cell.
Applying a result
Under a what-if impact on an input cell, and under a solved goal seek, an Apply button offers to write that value — the value you evaluated, or the input the solver found, even when it lives in a referenced cube. It asks once ("Write 750 to Cost × UK? This replaces the saved value.") and then saves it exactly as typing into the cell would, so a write into the open cube can be undone with Ctrl+Z. Two results are never offered: a pinned value on a calculated cell (use Goal Seek to find the input that produces it) and a goal seek whose input is a table cell (edit it in the table). Viewers see no Apply button at all.
Saved scenarios
A what-if worth coming back to can be kept. Under a what-if impact, Save as scenario names it and stores the override; add to puts the same override into an existing scenario, replacing an earlier value on the same cell, which is how a case like "Price +5%, Volume −3%, Churn 8%" is built one cell at a time. Scenarios… in the cell menu lists the project's saved scenarios: open one to see its overrides, Evaluate to see everything it moves, tick two or more and Compare to see them side by side — one column per scenario, the base value beside, the delta under each changed value, and the cell you opened the menu on always in the table — or Delete to remove it. A scenario is a saved hypothesis, not data — evaluating it writes nothing, and an override on a cell you may not see is listed as hidden and skipped. Viewers can evaluate; editors can save, grow and delete.
Promoting a scenario
Evaluating a scenario answers a question. Promote commits the answer: it writes the scenario's values into real cells, and it is the only thing in this pane that changes the model.
You get two forms. Left as it is, it writes over the cells the scenario names — this case is now the plan. Or pick a dimension and one of its items, and the values land in that slice instead — save this as the Budget version — which is how a case reaches a dashboard: it becomes an ordinary slice of a dimension your widgets already read, with nothing new to configure.
Promote always previews first. You see every cell, the value it holds now and the value it would take, and every override that will be skipped with the reason — a calculated cell (promote the inputs that feed it instead), a table cell, or a cell outside your access. Nothing is written until you accept that plan, and only editors are offered it.
Writing into a version nobody has filled in yet. A scenario names only the cells it changes — everything else it leaves at the value it already has. That is exactly right when you write the cells the scenario names, and a trap when you write into an empty slice: the inputs the scenario never mentions have no value there, so they stay blank, and the promoted case comes out disagreeing with the impact you just evaluated. A downside that never named Opex lands in an empty Budget with no Opex at all, and reports a better profit than the plan.
The preview says so when it happens: it tells you the target is empty and offers to copy the current values in first, so the scenario applies on top of a complete plan rather than on blank cells. Tick it and the preview refreshes, so what you approve is what runs. Promoting into a version that already holds a plan is unaffected — no warning, no copying, just the cells the scenario names.
Through the AI
The same questions are available to the assistant and to any MCP client,
under names that start with get_ because they are read-only (plus
save_scenario and delete_scenario, which write only the scenario record,
and promote_scenario, which commits values to cubes):
| Tool | Use it for |
|---|---|
get_what_if_impact |
"If Price rises 5%, what moves?" — one or more overrides, the impact across the chain |
get_goal_seek_solution |
"What exit multiple gives a 30% IRR?" — one input, one target |
get_sensitivity_table |
"How sensitive is EBITDA to price and volume?" — a 1-D or 2-D sweep |
get_monte_carlo |
"What is the range of EBITDA if price is ±10% and volume is normal(1000, 80)?" — inputs drawn at once, outputs summarised |
get_model_drivers |
"What are this model's assumptions / which inputs matter?" — every input some formula reads, ranked by how many formulas it feeds |
get_item_lineage |
"What feeds X?" / "What breaks if I change Y?" — the structure around one item |
get_scenarios |
"What cases have we saved?" — the project's saved scenarios, overrides labelled |
get_scenario_impact |
"Run the downside case" — a saved scenario evaluated across the chain |
get_scenario_comparison |
"Downside vs base vs upside on EBITDA" — 2–6 saved scenarios side by side, per cell |
save_scenario |
"Keep this as the downside case" — it saves the scenario record, never cube data |
delete_scenario |
"Drop the old downside case" — removes a saved scenario; no cube cell is touched |
promote_scenario |
"Save the upside as the Budget version" — commits a scenario's values to real cells, in place or into one slice of a dimension. The only one here that changes a cube |
get_simulations |
"What runs have we kept?" — the project's saved simulations, newest first |
save_simulation |
"Keep this as the Q3 risk case" — runs a simulation and stores the result; no cube cell is touched |
delete_simulation |
"Drop the old risk run" — removes a stored run |
A good sequence for an unfamiliar model: get_model_drivers to find the
inputs that matter, get_item_lineage to see how one of them reaches the
output you care about, then get_sensitivity_table or get_what_if_impact
to put numbers on it.
Only promote_scenario and set_cube_data commit a value; everything else
above answers a question and leaves the model alone. Ask for a preview
("show me what promoting would write") and the assistant runs it as a dry run
first. Promoting into a version that has never been filled in carries the same
trap it does in the pane — the assistant is told to warn you and to offer to
copy the current plan in first.
What the tools cannot do yet
- Table patches change what table references read; they do not re-run a table's own formulas or transforms.
Prior()andPriorDelta()read a shifted period and are reported by name in Explain rather than followed to a cell.
For the engine's exact guarantees, see docs/engine/shadow-evaluation.md in
the repository.