The compounding value of AI systems

Why each one should make the next one cheaper

Most companies budget their fifth AI system the way they budgeted the first: new data work, new approvals, a new fight for adoption. It doesn’t have to work that way. Each system can leave something the next one reuses, and become something the next one builds on. That is compounding, and it only happens on purpose.

Dušan StamenkovićFounding & Managing Partner · AI Practice LeadPublished 8 November 2026 · 9 min read
One platform, built underneath and on topLivePlanned
Underneath: the knowledge layer7 domain views over 300+ columns · definitions agreed with the domain experts · tests · an ownerDocument indexThe base for five platform featuresAI assistantReasoning agent · APIPrice predictionPlanned · feeds in from the sidefeedsOther AI systemsStatisticsDeep researchMCP connectionChartsOther agentsThe platformPowerPoint exportBUILT ON TOP
Underneath: the knowledge layer7 domain views over 300+ columnsDefinitions agreed with the expertsTests · an ownerDocument indexThe base for five platform featuresAI assistantReasoning agent · APIPricepredictionStatisticsDeep researchMCPChartsThe platformPowerPoint exportOther agentsBUILT ON TOP
A life sciences data platform we work on. Every system stands on the knowledge layer, and most of the newer ones are built on the assistant.Prosperaize client work, status as of 7 November 2026.

The idea in one minute

  1. 1Underneath: a system placed on the right level, with an owner, leaves things the next one reuses: connected and defined data, tests, an owner, and people who trust it.
  2. 2On top: once other systems can call it, a working system becomes a building block. The next one is a layer on top, not a project from zero.
  3. 3Neither happens by default. Choose each next system partly for what it reuses and what could build on it, and own what you build. The first system still has to pay for itself.

01

The model isn’t the asset

Most AI business cases treat a system as a project: a budget, a delivery date, a return. Then the next system gets its own budget, its own data work and its own fight for adoption, and it costs about as much as the first.

I look at an AI system the way a finance team looks at any asset: what it returns, and what it leaves the business able to do next. By that measure, the model is the least durable part. Models get replaced, and the same capability keeps getting cheaper. What lasts sits around the model: the data and its definitions, the tests, the owner, and the people who trust the answers.

The durable asset is the knowledge layer, not the model on top of it.

A portfolio of AI systems can compound in two directions. Underneath, each system leaves foundations the next one reuses. On top, each working system becomes a building block the next one calls.

Value against cost, system by systemIllustrative
ValueCost of the next systemSystem 01020304Illustrative: the shape to aim for, not a forecast.

Each new system starts lower because it begins from what the earlier ones left, and joins a value line that keeps rising. That is the shape to aim for. It isn’t what happens by default.

02

Underneath: what a system leaves behind

Placed on the right level and given an owner, a system leaves five things the next one can reuse.

1Connected, defined dataFrom Level 2What it isSources connected and reconciled, with definitions agreed with the people who know the domain.How the next system uses itIt starts with the hardest data work already done.
2TestsLevels 3 and 4What it isA test set, the cases that failed, and a log of wrong answers.How the next system uses itTesting starts ahead of zero.
3An owner and a recordEvery levelWhat it isA named owner, and an entry on the company’s list of AI tools.How the next system uses itReviews and approvals move faster.
4People who use itEvery levelWhat it isTrust, habits, and a team that knows what a good answer looks like.How the next system uses itAdoption costs less.
5The setup to run itLevel 4What it isDeployment, monitoring, and the cost of each answer tracked.How the next system uses itThe build is smaller.

What doesn’t carry over is just as useful to know: the model itself, prompts tuned to that model, and any setup you don’t own.

The cheapest of the five to create sits at Level 2 of the four levels of building AI systems. Connecting the subscription you already pay for to company documents, with permissions and onboarding by role, creates connected knowledge that every later tool can use. No-Code tools at Level 3 run on the same connections. Custom systems at Level 4 are easier to adopt when people reach them from the workspace they already use. Skip Level 2, and a custom build has to create those parts itself, inside a more expensive project.

The four levels of building AI systems →

03

On top: each system becomes a building block

The second direction is less obvious. A system that works can become a component: the next system calls it instead of rebuilding what it does. A statistics feature can stand on an assistant’s answers. A report can stand on the statistics. Another team’s agent can ask the assistant instead of querying the database itself.

For that, a system needs four things beyond working well:

01

An interface:an API, or an MCP server that other agents can call.

02

Stable answers:the same question returns the same numbers, with the records behind them.

03

Known limits:it says where its data ends and what it can’t answer.

04

An owner and tests:everything built on top inherits its mistakes.

So design the first system so the next one can call it, not only so people can use it. Otherwise it stays a dead end, however well it works.

04

One platform, built both ways

The diagram at the top of this post is a platform we work on at a Fortune 500 health data company: market access data on regulatory, HTA and reimbursement decisions across 90+ jurisdictions.

Its users could find any record but couldn’t get an answer to a question. A first attempt at an SQL agent worked on a single view of 10 columns. The data had never been described for a machine reader, and the rules for each jurisdiction lived with the experts. No agent could have worked on that data, whoever built it.

So the first thing we built wasn’t an agent. With the domain experts, we described the data. In a ten-week validation, paid for before any build, the first architecture, with the agent joining the tables itself, got a documented no-go. The design that passed put the hard joins into seven domain views over 300+ columns, so the agent only queries the right view. We stopped making the agent understand the database, and made the data understandable instead.

Everything after that was built underneath or on top:

01

The assistant, on the knowledge layer.Questions that took days are answered in under a minute. Regular use went from 10% to 55% of platform users, without a mandate. It was exposed as an API in one week.

02

A reasoning agent, on the same layer.It holds a conversation, corrects itself, says where the data ends and cites its records. It was tested side by side against the live system and rolled out in stages. It took 13 weeks, against 22 for the first build.

03

Statistics, charts and a PowerPoint export, on the assistant.Each one is built on the output of the one before it.

04

Deep research, on the assistant.Several queries behind one question, ending in a report that exports the same way.

05

An MCP connection, planned.So other agents, and the platform itself, can call the assistant.

06

Price prediction, planned.Built from the side, its output will feed the assistant and other AI systems.

07

A document index, planned.The base for five platform features, each built on the same index.

The client moved from selling data to selling insights. It launched a new subscription tier.

05

Why most organizations never let it

None of this is technically hard. It fails on how AI gets bought and owned.

—

Each system is bought on its own,by a different department, often from a different supplier, so nothing is shared.

—

Advice, delivery and support sit with different people.Nobody is paid to plan the second system while the first one is being built.

—

Levels 2 and 3 get skipped.Companies go from the subscription straight to a custom build, so the connections, permissions and habits every later tool could share never get built.

—

Nobody asks who owns what was built.If the code, the data model or the definitions aren’t yours, the next project starts from scratch. Ask before you sign.

—

Nobody owns it after launch.A system without an owner decays, and nothing gets built on something that decays.

—

Each system is judged alone.A business case that ignores what a system leaves behind undervalues the first system and overprices the second.

06

The trade-off

Compounding isn’t free, and it isn’t always right.

—

Reuse costs more up front.Modular design, documentation, a named owner and an interface others can call all make the first system take longer.

—

Future reuse doesn’t rescue a first system that doesn’t pay.If it only pays once three more are built on it, you are betting on systems nobody has funded yet.

—

Shared foundations mean shared risk.A change to the knowledge layer or the assistant reaches everything built on it, so the interfaces need versions, tests and an owner.

—

Not everything should be shared.One-off tools don’t need to be, and some data has to stay apart by rule, which comes up often with health data.

—

Some systems should be retired.A portfolio that only grows carries running costs nobody reviews.

07

How to count it

One test, every system

The decision a system improves, times how often that decision is made, has to be worth more than what the system costs plus what its wrong answers cost.

Compounding changes two inputs to that test:

01

The cost of the next system:count it net of what it reuses. If the data work is done, it isn’t in the new budget.

02

The ranking of options:put what each option reuses, and what could later build on it, next to what it returns.

It doesn’t change the first system’s value. Don’t add future reuse to it. Count reuse when the second system is funded, and check it when the second system ships.

08

How to set it up

01

List every AI toolyou pay for or run, and what each one leaves behind.

02

Place each oneon one of the four levels.

03

Name an owner for every systembefore it goes live.

04

Own what is built:the code, the data model and the definitions. Write it into the contract.

05

Before any build, ask two questions:what does it reuse, and what could build on it next?

06

Give each working system an interfaceother systems can call.

07

Measure the second system against the first:its cost, its time to the first useful answer, and its payback.

08

Keep the same partner across systems,so the person who made the first decision sees what should come next.

09

How to tell if it’s working

—

Time to the first useful answerfalls with each new system.

—

The share of data work reusedrises.

—

Days from idea to decisionfall.

—

The cost of each new buildfalls, against what it would have cost on its own.

One measured pair so far: on the pharma data platform, the second system took 13 weeks, against 22 for the first.

The first system has to pay for itself. The second should pay for itself sooner.

Find out what your next system could reuse.

Schedule a call with a partnerFree until 11 December