What is AI vendor lock-in?

AI vendor lock-in is what it would cost to leave an AI platform: the data to move, the rules to rebuild and the tools to rewrite. It is rarely signed. It builds up month by month, as a platform collects records, access rules, prompts and the tools people come to rely on.

Two things set it apart from ordinary software lock-in. An AI platform depends on a model that someone else retires on their own schedule. And it sits on top of other systems, so it copies their data and often their permissions. Every copy is something you may have to take with you, or rebuild.

• Model. Prompts tuned to one model, tools described in one vendor’s format, an API only that vendor serves. When the model is retired, everything written for it is tested again. Anthropic’s deprecation page states the end plainly: “Requests to retired models fail.”
• Data. Records copied into a vendor’s store, and the links the platform worked out between them: which ticket is about which part, which supplier notice changed it. The records may export. The links often do not.
• Permissions. Who may see what. A platform that keeps its own grants has a second rulebook, and someone rebuilds it by hand on the way out.
• Logic. Schemas, tools, agents, workflows and screens. If they exist only inside a vendor’s editor, leaving means writing them again.
• Runtime. Where it runs and who holds the keys: the servers, the encryption key, the sign in setup and the people who know how to operate it.

The layers cost different amounts to leave. Lock-in at the model costs a round of testing. Lock-in at the data and the logic costs a project.

The costs of switching are best measured in cloud computing, where regulators have looked closely. The UK Competition and Markets Authority’s final decision on cloud services, from July 2025, found that “less than 1% of customers switch provider each year.” It named two kinds of barrier. Egress fees charge for moving data out. Technical barriers come from features and interfaces that differ between providers, so customers cannot easily compare or substitute them.

An AI platform adds costs of its own:

• Testing every prompt and tool again on a new model.
• Exporting records together with the links and the enrichment built on them.
• Rebuilding access rules, and showing an auditor that they match the old ones.
• Rewriting tools and agents that existed only in the vendor’s editor.
• Teaching the people who built and used them a new system.

The law has started on part of this. The EU Data Act sets out to “overcome vendor lock-in, which undermines competition and the development of new services.” It requires providers of data processing services to remove obstacles to switching. From 12 January 2027 they may not charge for the switching process. Its rules are about moving data and digital assets. They do not make a prompt written for one model work on another.

Some lock-in is the point. After a year, a useful platform holds a year of work: records joined across systems, rules about who sees what, tools a team depends on. Leaving costs that work on any platform. Building it yourself does not avoid it either. Your own code locks you into your own team’s time.

One question separates the two kinds: would you stay if leaving were free? If yes, you stay for what the system does. If you stay because your data, your rules or your code are stuck inside, that is the lock-in to avoid. The difference is where the work lands: in assets you hold, or in a vendor’s format.

Ask per layer, during the evaluation rather than at the renewal, and ask for the answers in writing:

1. Can we change the model by configuration, open weights on our own servers included?
2. Where do our records and the links between them live, and in what format do they leave?
3. Are permissions read from our source systems, or kept as a second set of grants?
4. Can we export what we built (schemas, tools, agents) as files we can read and version?
5. Who holds the servers and the encryption key?
6. What does the contract say about notice, a transition period and exit fees?

Then test two of them on the pilot. Export what it built and read it. Change the model and see what else changes. A vendor that cannot show both before you sign is unlikely to make it easier afterwards.

We built Curiosity Studio so that the lock-in lands in what you hold. The model is a setting: 19 providers are built in, and any OpenAI compatible endpoint works too, open weights on your own servers included. What is a model agnostic AI platform? explains how that works and what still needs testing.

Connectors copy what they map into one graph on your deployment, and each record links back to the system that owns it. Those systems stay the systems of record. Access is synced from them and checked per record at query time, so there is no second rulebook. Studio can commit every configuration change to a git repository and push it to your remote, as the configuration sync documentation describes. It runs on premises or in your private cloud, encrypted at rest under a key you hold.

The switching cost that remains is the work: the graph, the enrichment and the tools your teams built. Our paper The vendor lock-in you always wish you had goes through it layer by layer, with six questions to ask any vendor, us included.