Finance Software Went Closed. Developer Tools Went Open. AI Is Ending the Divide.

Try to test a serious financial planning tool this week. Not a spreadsheet, a real one: Anaplan, Pigment, Vena, Planful. You can't. There is no sign-up button, no free tier, no sandbox you spin up over coffee. You book a demo, talk to a sales rep, get scoped, get quoted, and if the number clears procurement you start an implementation that runs in months. This is not an accident of any one vendor. It is the entire category. Financial planning software, as a rule, cannot be tried without a human on the other side deciding whether you are allowed to.

Now open a terminal. In fifteen years, developer tooling went the exact opposite direction. Git is free and open. GitHub is free while you work alone. dbt's core is open source. You can install, fork, break, and export almost anything a developer touches without asking anyone's permission. The default posture of developer tools is open. The default posture of finance tools is closed.

These are two opposite cultures, built on opposite assumptions about who owns the work. And for the first time, something is pulling them together: the arrival of AI agents inside finance. It is worth understanding why the divide existed at all, because the reasons it made sense are the same reasons it is now starting to break.

Two cultures, point by point

The contrast is not vague. It shows up on every axis that matters.

Four axes on which the two cultures made opposite choices.

Access. Developer tools are self-serve by default. You try before you buy, alone, for free. Finance planning tools are sales-gated by default. You are qualified before you are allowed to touch the product.

Format. A developer's work lives in open, documented formats: plain text, JSON, SQL, files you can read with any editor and move anywhere. A financial model lives in a proprietary format, or in a spreadsheet whose logic is trapped inside the cells. There is no shared, documented standard for what a financial model is.

Portability. Developers assume they can leave. Export is a right, not a feature. In finance software, your data and your logic are the retention mechanism. The harder it is to leave, the better the vendor sleeps. Lock-in is not a bug in the business model, it is the business model.

Ownership. Open standards say the artifact is yours. Closed platforms say the artifact is theirs, and you rent access to it. When you stop paying, in the developer world you keep your repository. In the finance world you often keep nothing you can actually use.

None of this happened out of malice. Finance software went closed for reasons that were, for a long time, entirely rational.

Why finance went closed (and why it worked)

Enterprise finance software was sold to buyers who valued control over openness, and who were right to. The numbers are sensitive. The buyer is a CFO or a finance director whose job depends on the model being governed, permissioned, and auditable, not on it being forkable by a curious analyst.

Sales-led distribution followed naturally. When the deal is six figures and the implementation touches the close process, you do not want a self-serve funnel. You want an account executive, a solutions engineer, and a contract. The absence of a free tier is not laziness, it is a deliberate filter: this product is not for people who want to try things alone.

Proprietary formats followed too. If the model is the value, and the model only runs inside your platform, then the format being closed is a feature. It keeps the logic inside the walls where the governance lives, and, conveniently, where the renewal lives.

For twenty years this was a coherent system. It produced real companies with real value. The problem is not that it was wrong then. The problem is that the assumption underneath it, that finance work belongs to the platform and not to the person doing it, is exactly the assumption AI agents violate.

What AI actually changes

An AI agent is not a user who logs into a platform. It is a process that reads, reasons, and writes on your behalf, and it works best when it can reach across everything at once: your model, your accounting data, your conventions, your documents. Its whole value is composition. And composition is precisely what closed systems are built to prevent.

This is where the developer world's open primitives stopped being a cultural preference and became a technical requirement. Consider what agents actually need:

An open protocol to reach tools. MCP, the Model Context Protocol, is an open standard for letting an agent talk to external systems. It is open on purpose. A closed, per-vendor integration does not scale to an agent that needs to touch ten tools in one session. The industry is converging on open connective tissue because agents make closed connective tissue useless.

Portable context the agent can carry. An agent that starts every session by re-learning your model from scratch is an expensive agent. It needs the structure, the conventions, and the history to exist somewhere it can read them directly. That "somewhere" has to be a format, not a screen. A format is, by definition, portable. You cannot build durable agent context on top of a closed UI.

Skills and conventions it can share. The developer world already learned that the reusable unit is not the app, it is the small, shareable, forkable artifact: the package, the template, the skill. Finance is starting to grow the same layer. A documented convention file that says what this organization means by EBITDA, which FX policy applies, which items are normalized, is worth more to an agent than any dashboard. And a convention only has value if it is open enough to be read, shared, and reused.

What an open finance stack looks like

You can already see the shape of it, borrowed almost line for line from the tools developers have used for a decade.

Open conventions instead of tribal knowledge. The single most valuable thing to make readable is not the numbers, it is the rules behind them. An open, documented convention file, versioned alongside the model, is the finance equivalent of a README or a schema. It travels with the work, not with the analyst who is about to leave. (One early attempt at standardizing this is FINANCE.md, a plain-text spec for encoding financial conventions an agent can read at session start.)

Portable models instead of trapped ones. The logic of a model, its variables, dependencies, and timelines, expressed as a documented structure rather than a proprietary binary or a spreadsheet's tangle of cells. Something you can read, diff, version, and move. dbt did this for analytics by separating structure from data. Finance modeling is due for the same separation.

Forkable templates instead of blank platforms. The developer default is: start from someone else's working artifact and change it. A public library of forkable deal models, SaaS models, or budgeting structures does for a finance team what a package registry does for a developer. You inherit a reasonable starting point instead of rebuilding from zero every quarter.

Export as a right, not a lever. In an open stack, getting your clean, auditable numbers out into Excel or anywhere else is never the thing you pay to unlock. Paywalling the exit is the closed world's instinct. Charging for genuine collaboration, governance, and scale is the open world's.

Free while you are alone. This is the piece the finance category has almost never offered, and it is the one developers take for granted. GitHub is free for one person. Obsidian is free for personal use. The logic is simple: let people feel the value alone, at zero friction, and charge when the work becomes a team's work. Applied to finance, it inverts the sales-gated default. You try it alone, for free, and you pay when an organization depends on it.

Each of these is unremarkable in developer tooling. Each is close to unheard of in finance planning software. That gap is the opportunity, and it is closing.

Where closed still wins

None of this means the closed model was a mistake or is about to vanish. It means the default is shifting, not that the old approach has no place.

Large enterprises with strict governance requirements still have real reasons to prefer a controlled, permissioned, single-vendor platform. When the audit committee needs one throat to choke and the finance org has hundreds of contributors, the openness that helps a solo builder can look like risk. Regulated environments, deeply integrated close processes, and workflows where the whole point is centralized control are not going to be won by a fork button.

The honest framing is not "open beats closed." It is that the market was, until now, closed by default and open only as an exception, and that AI is flipping which one is the exception. For the individual practitioner, the small finance team, the analyst who wants to try something on a Sunday, the default is becoming open. The closed world contracts to where governance genuinely demands it, instead of covering the whole map because there was no alternative.

The bottom line

Finance software stayed closed while nearly everything else in technology opened up, and it worked, because the buyer valued control and the vendor valued lock-in and both got what they wanted. AI breaks that equilibrium. Agents do not log in and click, they compose across systems, carry context between sessions, and work best on open formats they can read directly. The primitives that make that possible, open protocols, portable structure, shared conventions, forkable artifacts, are the ones developers have relied on for years and finance has mostly done without.

The direction of travel is clear. The reusable unit in finance is starting to look less like a platform seat and more like a file you own. The convention is becoming a document, not tribal knowledge. The model is becoming portable, not trapped. And the on-ramp is becoming free for one person, the way it has long been for developers.

Finance is having its developer-tooling moment. It is a decade late, and it is arriving all at once.

Layerz is a financial modeling workspace built on this thesis: an open convention layer, models you can read and export, and agent access over an open protocol. Free while you work solo. See how it works.