Ask the exit question before you enter

The question that gets skipped

Adoption conversations cover capability, price and data handling. They almost never cover the one that decides your position in two years: what does it cost to stop?

This matters more than usual here for a specific reason. The field is moving fast, prices have moved by order-of-magnitude factors in both directions, and the best option for your work has changed at least annually. A tool you cannot leave is a bet that today’s leader stays the leader, and nothing in the last three years supports that bet.

Where lock-in actually accumulates

Not in the model. Models are the most swappable part, which surprises people.

Your prompts and agent instructions. If these live in a vendor’s console, in their project settings, in a web interface, they are theirs. If they live in your repository as files, they are yours. This is the single highest-value decision on the list and it costs nothing to get right.

Your evaluation suite. The set of cases that tell you whether output is good enough for your work. Built inside a vendor’s evaluation product, it does not come with you, and without it you cannot assess the alternative, which is how you end up unable to leave something you know you should.

Fine-tuned weights. Almost universally non-exportable from a hosted provider. You can leave; you cannot take the adaptation. Any fine-tune on a hosted service should be treated as rented.

Proprietary agent and workflow formats. Configuration in a bespoke format that no other tool reads. Small in volume, large in rewriting effort.

Your team’s habits and shortcuts. The least discussed and often the largest. Two years of muscle memory has a real retraining cost, and it is why teams stay with tools they no longer rate.

Five things that keep the door open

Keep prompts and instructions in the repository, in version control. Plain files, reviewed in diffs, portable by definition. You want this for reproducibility anyway.

Write your evaluation suite as ordinary tests. A directory of cases and a script that scores them, in your language, in your repository. It becomes the instrument that makes every future comparison possible.

Prefer an interface several providers implement. A large number of providers, including local runtimes, expose an OpenAI-compatible endpoint. Building against that shape means switching is a base URL and a key.

client = OpenAI(base_url=os.environ["LLM_BASE_URL"],
                api_key=os.environ["LLM_API_KEY"])

That is not elegant architecture. It is one environment variable standing between you and a rewrite.

Keep a local fallback and test it quarterly. A quantised open-weight model through llama.cpp or ollama, wired to the same interface, exercised often enough that you know it works. It is your answer to an outage, a price rise and an acquisition, and the quarterly test is what stops it being a fiction.

Avoid deep integration into anything you would not rewrite. If a tool’s output is fed automatically into three internal systems, you have built a dependency whose removal is a project.

When lock-in is the right choice

This is not an argument for portability at any price. Sometimes the integrated thing is much better, and accepting the switching cost is correct.

The requirement is that you price it before you commit, and write the number down. “Moving off this would take us about three weeks, mostly rebuilding evaluations and retraining the team” is a sentence that turns a hidden dependency into a known one, and it is the sentence that makes the later decision possible rather than paralysing.

The failure is not choosing lock-in. It is arriving at it without noticing, and then discovering the cost at the moment you most need to move.

The free path, which is also an exit

A local open-weight model on your own hardware has no exit cost by construction, and this is its strongest argument, stronger than privacy, which is what people usually cite.

Be honest about what you give up: on hard reasoning tasks the gap between a small local model and a large hosted one is real, and pretending otherwise helps nobody. But a local model is a floor under your capability that nobody can price, deprecate or withdraw, and the existence of a working floor changes every negotiation you have afterwards.