Why typed.

When a CFO emails his board an .xlsx, the deliverable is the workbook. But the artifact, the thing the deliverable is supposed to be evidence of, is the model: the structured set of beliefs about how the business produces money over time. The workbook is a rendering of the model into a particular substrate.

For four decades that substrate has been the spreadsheet. The substrate has properties (cells, formulas, ranges, sheets) and missing properties (no types, no named drivers, no assertions, no audit trail, no deterministic re-evaluation). The properties were chosen for general-purpose flexibility. The missing properties are why every financial model produced in the substrate decays the moment it's saved.

Read the post-mortems of any famous spreadsheet failure: JPMorgan's London Whale, Reinhart-Rogoff, Knight Capital, the UK pandemic case-tracking spreadsheet that lost 16,000 cases. In every one of them, the operator did everything right within the bounds of what the substrate allowed. The bounds were wrong.

A typed range cannot silently drop the bottom five rows of a list. A named driver cannot be confused with a hardcoded cell. A structural assertion that “cash runway must be ≥ six months” either compiles into the model or it doesn't; there is no “forgot to write the check.” A compiled DAG re-evaluates the same way every time, on every machine, regardless of who opens it.

These are not features the operator can opt into. They are properties of the substrate. If the substrate doesn't express them, the model can't carry them. The operator's diligence cannot compensate for substrate-level invariants the substrate refuses to enforce.

For most of those four decades, the spreadsheet's tradeoffs were acceptable. The operator was a human, and humans hold structural intent in their heads even when the substrate doesn't. The compiler-in-your-head was the audit trail. It was imperfect, but the loss was bounded by how many humans had to handle the model.

AI agents removed the bound. An agent will produce a 200-driver model in eleven minutes. A second agent, or a different prompt of the same agent, will modify it in three. By the time the human looks at the workbook, the compiler-in-your-head has nothing to anchor on. There is no version of the model the human ever held in working memory. The audit trail collapses to vibes.

The correct response to this is not to slow the agent down. It is to upgrade the substrate so the agent can author into something that can be audited at the speed it ships.

Software engineering went through the same arc. In 1995, untyped scripting languages dominated server work; by 2010, the largest production codebases were rebuilding themselves in typed languages with compilers, tests, and version control. Not because typed code is intrinsically virtuous, but because the cost of an untyped error scales superlinearly with codebase size and team size.

Financial reasoning is at the 1995 moment. Excel is the perl of finance: maximally flexible, fast to start with, lethal at scale. What replaces it is not another grid. It is a typed compilation layer underneath the workbook, where the workbook becomes a rendering target, the same way HTML became a rendering target for typed application code.

A typed financial model has, at minimum, four properties an untyped one does not:

1. Named drivers with declared types. Not B7, but gross_profit: Currency(USD).
2. Compile-time dimensional inference. Currency − Currency → Currency is a check the compiler runs before producing a number. Count × Percentage → undefined warns.
3. First-class assertions. burn_multiple < 1.5 is part of the model, not a comment.
4. Deterministic re-compile. Same IR, same output, every machine, every time. Bit-identical.

Each of these is independently boring. Together they constitute a category change: the model becomes an artifact that can be verified, recomputed, and reasoned over by something other than a human eyeballing a sheet.

The honest tradeoff: the cell-level immediacy of the spreadsheet. In Excel, you click a cell, type a formula, see a number, and iterate in a tight loop measured in seconds. That loop is genuinely valuable for exploratory math and one-off calculations. We do not claim to replace it.

What we replace is the moment the exploratory math has to become a model: when the numbers will be shown to other humans, audited, recomputed, or shipped to a regulator. That is the moment the spreadsheet's tradeoffs flip from acceptable to lethal. That is the substrate change Flatland makes.

You don't learn a new tool. Your agent does. You describe a business in natural language; your agent (Claude Code, Cursor, anything that speaks MCP) calls Flatland; Flatland compiles a typed model and hands back an Excel export your investor already knows how to read. The substrate change is invisible to everyone except the agent and the audit trail.

The model lives in IR: a typed, versionable, diffable JSON. The workbook is one rendering of it. The audit trail is another. The sensitivity analysis is another. All three are deterministic outputs of the same compile.

The investor opens the .xlsx. Your team is having the model conversation by Wednesday morning instead of three weeks of Slack messages and a rebuild.

Financial reasoning will run on a typed substrate within ten years. It will happen because the AI-agent population in finance is past the point where the compiler-in-your-head can keep up, and the cost of an untyped error is now compounding faster than humans can review.

The only question is whether the new substrate is something the field rebuilds itself, or something a vendor ships. Our argument for the second path is that we've been rebuilding it for two years, the engine is live, and the artifact your investor opens is identical to the one Excel produces today; just generated from a typed compile graph underneath.

We're building the substrate. Your agent calls the engine. The model becomes an artifact that survives the next analyst.

→ Try the Workshop · Read the Excel comparison · Read the Reinhart-Rogoff teardown