We let you leave. That's why you'll stay.

In the last note I argued that apps were for clicking and Munin isn't — that once the cheapest operator in the system stops being a person, the UI stops being the product. This note is the commercial half of that argument: if the software isn't the product, what is? It's the half founders usually keep quiet about. I'd rather say it out loud.

So, plainly: we built the whole of Munin — knowledge, conversations, CRM, content, outreach, the lot — in roughly a month, and we licensed it MIT. The repo is public. You can clone it tonight, read every line, and have it running on your own metal by the weekend. We are not worried about that. We did it on purpose. The month was never the moat, and we'd rather be the ones to say so.

The build was the cheap part

I want to be precise about what "a month" does and doesn't mean, because the figure invites the wrong reaction in both directions.

It doesn't mean the work was trivial. It means the production of software has gotten radically cheaper, and a small team with good taste and agentic tooling can now ship in weeks what used to take a funded company a year. That's not a Munin achievement. It's the weather. Everyone is building in this climate now, whether they've noticed or not.

And it doesn't mean the result is a demo. The part that took the actual care isn't the part you'd time with a stopwatch — it's the five apps sharing one Postgres with row-level security carrying the tenant boundary, the consent state that decides what an agent is allowed to surface, the audit log that survives a bad night, the EU-hosting posture, the on-call rotation behind it. The build was fast. The operating is not, and was never meant to be.

That gap — cheap to build, expensive to run well — is the whole essay. If a competent team can reproduce the code in a month, the code cannot be the thing you're paying for. Something else has to be. The interesting question is what.

The open door

Most software companies treat the exit as a thing to make quietly impossible. The data lives in a proprietary store. The export is a CSV with half the fields missing. The integrations are a one-way street in. You don't leave, because leaving is a project, and the project never makes it onto anyone's quarter.

We went the other way. I want to be concrete about it, because a promise of portability that stays abstract is just a slogan.

The code is MIT. No open-core bait-and-switch, no "community edition" with the useful parts filed off — the thing we run is the thing in the repo.

And leaving isn't a project you dread. It's a handful of tool calls. Each of the five apps exposes a matched pair: an export that hands you its data and an import that takes it back. Knowledge, conversations, CRM, content, outreach — each with its own symmetric door.

Because they're tools behind the MCP protocol, not buttons welded to our UI, an agent can walk all five for you. Point it at your Munin instance and a fresh one you've stood up yourself; it reads each app out of the old and writes it into the new, the whole tenant moving across while you watch. No CSV with half the fields missing. No migration quarter. The exit is an agent run — the same shape as everything else Munin does.

We point you at the door rather than stand in front of it.

That should, by the conventional logic of this industry, be a terrible idea. It is the opposite of lock-in, and lock-in is supposed to be the business.

So what are you paying for

The same things that survive the undoing, it turns out, are the things you bill for. In the last note I said the parts that survive an agentic world are the unglamorous ones: the data model, the identity layer, the audit log, the consent state, the place where humans approve things. That list wasn't just an architecture diagram. It's a price list.

You're not paying us for the software. You're paying us to operate it — and operating is where all the scarce things live:

• 01Residency and posture. The data sits in the EU, under a security and compliance stance that's real work to maintain and real liability to get wrong. Most teams would rather rent that than own it.
• 02The accountable party. When an agent does something it shouldn't — surfaces a record it had no business surfacing, sends the wrong thing to the wrong person — someone has to be the legible, answerable party, with the audit trail to reconstruct what happened. That's a role, not a feature. It doesn't come from the source code.
• 03Continuity. Uptime, upgrades, the migration that doesn't lose a row, the on-call human at the unsociable hour. The repo doesn't page anyone at 03:00. We do.

None of these are things you can fork. You can copy the code in an afternoon. You cannot copy being trusted to run it, because trust isn't in the artifact — it's in the operation, accrued over time, and it's the one thing that doesn't get cheaper as the tooling improves.

This isn't a new shape, exactly. Red Hat sold an operating system nobody could own, and built a serious company on support, assurance, and being the throat to choke. What's new is that the cost of building fell far enough that this stops being a story only about giant infrastructure projects and becomes available to ordinary business software — the CRM, the helpdesk, the five apps that touch the customer record.

Why the open door is the lock

Here's the inversion the whole bet rests on. The open door isn't a concession we make despite wanting you to stay. It's the reason you'll stay.

Lock-in was the old moat: you stayed because leaving was too painful to attempt. It worked right up until it didn't — and it turned the last decade of SaaS into one long syncing project, a tax everyone paid and no one wanted. Portability is the new moat, and it works in reverse. You let people leave freely, and the freedom is exactly what makes them comfortable handing you the thing that matters most: the live operation of their customer relationship. Nobody hands an irreversible decision to a vendor they can't escape. They hand it to the one they could leave at any time and choose, every month, not to.

You stay because you could go. Take the door away and you've taken the trust with it.

The bet

So the bet is plainly this. Software has become a commodity in the only sense that matters commercially: the artifact is no longer the scarce thing, and pretending otherwise is a strategy with an expiry date. What stays scarce is the operation — the residency, the consent, the audit, the accountability, the person who answers when it breaks. We open-sourced the code because the code was never going to be the moat, and we'd rather build on the part that lasts than defend the part that doesn't.

We let you leave. That's why you'll stay.