Over the years at Startup Bakery we have signed quite a few contracts, and we have seen the same scene repeat itself more often than I like to admit. The demo goes well, the client likes the product, the contract gets signed. Then three or four months go by, you look at the usage data and discover the client has hardly ever set foot inside the platform. The contract is there, so is the revenue. The problem you were supposed to solve, though, is exactly where you left it.
You had sold them a tool. And the tool, to them, was never really the point. They wanted the problem to disappear, and using the tool to make it disappear was work that still fell on them, with time and skills they often did not have.
The tool was never the product
Software has always sold the same promise: I give you the ability to do something better and faster. The trouble is that the ability is not the outcome. Between “I give you the system to keep your spend under control” and “your spend is under control” sits all the effort the client still has to make. And that effort, let’s be honest, most of the time never gets made.
For years this was a technological limit, not a choice. We could not deliver the outcome, so we delivered the closest possible tool and crossed our fingers. With agents, that limit is crumbling: the work you used to offload onto the client, you can now keep in-house. It is the direction we are working on at Startup Bakery, and it is much more than a change of slogan.
What changes in the price
When you sell a tool, the price is anchored to access. So much per user, so much per month, maybe three tiers and off you go. It is convenient, it is predictable, and it is the reason we got used to thinking in licences.
When you sell an outcome, that anchor comes loose. The client stops buying “five seats” and starts paying you because you handle the invoices in their place. What they buy is the result; the software, in itself, interests them only so much.
And you can usually charge more for the result. Not because you are expensive, but because you are taking on a slice of work the client used to do in-house, and that work has a cost they know very well: it is hours of someone on their team. Arguing over that number is much easier than explaining why your subscription costs 49 euros instead of 39.
There are then many ways to package it: a price per single outcome, a share of the savings you generate, a fixed fee on a guaranteed result, or a mix. Which one works depends on how measurable that outcome is and how clearly it is your doing. And this is where things get slippery.
The risk comes home with you
Selling the outcome for real means taking into the house something that, with the tool, stayed outside the door: the risk.
With the tool, the execution risk stays with the client: if they use it badly, that is their business. With the outcome, that risk becomes yours. If the agent gets it wrong, if the output needs rechecking, if the result does not arrive within the promised time, you can no longer say “you didn’t configure it properly”. You simply did not deliver.
Two practical consequences follow. The first is that the price must incorporate a margin for the risk you are taking on. The second is that behind it there must be a machine that holds up the promise: quality checks on the output, monitoring, someone (or something) that notices when things go off the rails. Without that machine, the outcome model is just a refined way of losing money.
Putting it in writing
A rule I learned at my own expense: the outcome must be written down in a measurable way, otherwise the contract is just a lawsuit postponed. “Improving efficiency” means nothing. “Invoices categorised and reconciled without manual intervention, and renewals flagged before they kick in” means something.
A few things must be fixed beforehand, not argued over after the damage is done: what counts as delivered, where the measurement starts from, what happens if the outcome does not arrive. And you need a sharp boundary of responsibility: if the client feeds you wrong data, the wrong result cannot fall on you. It sounds obvious, but it is exactly the kind of thing you end up fighting over six months later if you did not put it down at the start.
Then there is something trivial and decisive: SLAs go on the outcome, not on uptime. The client does not care much that the platform is up 99.9% of the time. They care that the result arrives.
A concrete case: Kontai
An example we have in-house is Kontai, one of our studio’s startups. Kontai manages a company’s recurring spend: software subscriptions, utilities, licences, all those costs that multiply and that almost nobody manages to hold together, because they are scattered across emails, invoices, company cards and contracts everyone forgot they signed.
The “tool” version of a product like this we all know: a dashboard where you upload the expenses, categorise them and keep an eye on renewals. Tidy, nice to look at, and with the same fate as so many dashboards: you open it the first month and then never again. Because keeping it up to date remains a job on the shoulders of the finance team, which has no time to spare.
Kontai is taking the opposite road. The AI captures invoices from the email inbox and the payment systems, reconciles and categorises them on its own, warns before a renewal kicks in, flags anomalous charges before they slip through unnoticed. The client does not have to “use a tool”: the product does the work. What they are left holding is the outcome, that is, actually knowing how much they are spending and no longer discovering renewals when they have already gone through.
You can tell from how the client is approached, too. It does not start with “try the software”, it starts with a free assessment that photographs how (im)mature the company is at managing its recurring costs, with concrete steps to take. First the outcome, then, if anything, the features. And that is where, over time, the price can hook onto what the client really cares about, that is, the spend they manage to keep under control and the money they put back in their pocket.
In conclusion
In the end, the product was never the software. It was always the outcome. It is just that, until yesterday, we did not know how to deliver it, so we sold the tool and hoped the client would do the rest. Today that “rest”, piece by piece, we can start doing ourselves.
What changes, deep down, is what you have in front of you when you sign: no longer the promise that the client, with enough effort, will manage on their own, but the problem already solved. It is a less comfortable trade than the old one, it takes on more risk and offers fewer shortcuts. It is also much harder to copy, and that is exactly why it is worth getting into now, while almost nobody is doing it seriously.