A friend at a SaaS company once told me the vendor they hated most was the one they couldn’t leave. Not the one that overcharged. Not the one that broke their integrations every quarter. The one with the proprietary export format, the custom DSL, the data model that needed a six-month consulting engagement to migrate off.

They renewed anyway. Of course they did. The contract was up. The migration cost was higher than another year of mediocrity. So they sent the wire and went back to complaining in Slack.

That’s the real definition of vendor lock-in: a switching cost so high that staying with the worse option becomes the rational choice. The product never trapped them. The math did.

The math is changing.

An agent can read a vendor’s data export, infer the schema, generate the migration scripts, and validate the result against a sample. Some things that used to take a quarter and a contractor now start with a weekend and a transcript. The activation energy of leaving is dropping from “strategic initiative” to “credible weekend project,” and that changes the negotiation.

This is how the lock-in model starts to leak. The proprietary config format used to be a moat. Now it’s a parsing problem. The custom DSL used to require a multi-month port. Now an agent can transpile it overnight, run it against the new system, and tell you what edge cases blew up. The “but we already integrated with their API” objection used to win the renewal conversation. Now someone hands you a PR.

The smart vendor sees this early and runs the same trick from the other direction. Build a one-click migrator from your biggest competitor. Pre-translate their export formats. Take their backup, hand back a working environment in your product. Pay down the prospect’s switching cost out of your own marketing budget. That is what it is.

Same playbook as “we’ll buy out your contract.” It just got cheap enough to run for software, not just gym memberships.

Not all switching cost is technical, of course. Procurement, retraining, audit obligations, the VP who picked the vendor and would rather not relitigate that meeting — none of that goes away because an agent can write a transpiler. But the technical floor used to be the dominant cost for most teams. Lift that, and the rest becomes negotiable.

What’s telling is that engineering teams were already wise to this, long before agents could write code. Look at where greenfield adoption goes. Postgres, not the proprietary database with the slick demo. Standard formats. Open APIs. Tools that shrug when you say “we might leave one day.” The platforms that win the first decision are almost always the ones that don’t try to win by capture.

Trust opens the door. The escape hatch keeps it open.

The paradox of a low switching cost is that it doesn’t get exercised much. Once you can leave whenever you want, the urgency to leave evaporates. You stay because the product is good, not because the contract is tight. That is a healthier relationship for everyone involved, the vendor included. They have to compete on the product instead of the moat.

Some lock-in survives this. Network effects, regulatory friction, deeply bespoke workflows that took years to encode. Hard to migrate a stock exchange in a weekend. But the run-of-the-mill kind — proprietary formats, custom DSLs, “we own your data” — has lost most of its pricing power. Anyone building a moat out of switching costs in 2026 is going to spend a lot of time patching the same leaks.

The platform teams I’ve trusted most have always operated this way: standard interfaces, open formats, “you could do this without us” treated as a feature, not a threat. They were right early. The market is finally catching up to them, with a lot of help.

The lock-in vendor isn’t adapting. They’re hoping you don’t notice that the door is open.

Related reading: