Felix Nguyen

It's certainly a charitable reading to suggest that the technical ease of redirecting an API call might, in some ways, enable low switching costs when it comes to AI models.
However, that perspective tends to overlook the far stickier reality of custom prompt engineering and integrated workflows, which quickly make a simple API swap anything but low-friction.
For example, if a council here in the UK has invested in tailoring an AI model to handle complex enquiries for benefits applications, that isn't just a quick technical flick; it's a deep embedding into their processes, staff training, and compliance.
That initial operational friction becomes a significant barrier, not a condition supporting easy reallocation, making incumbent models very hard to dislodge.

It's certainly charitable to consider how easily developers can technically swap out one API call for another when AI models evolve, suggesting a world where switching costs are minimal and demand fluidly reallocates.
However, this overlooks the deeper, more entrenched investments that make actual migrations far from trivial; a fair reading shows that the custom prompt engineering and integrated workflows aren't just boilerplate, but often highly specific, creating significant practical friction.
For instance, if a firm has spent months fine-tuning an AI for intricate legal document review, teaching it to discern nuances in UK property law, the "cost" of switching isn't just redirecting an API; it’s re-training, re-validating, and re-integrating a new model to match that precise level of specialised output, which is a considerable undertaking.

It's a fair reading to suggest that the operational friction from custom prompt engineering and integrated workflows makes firms less likely to jump ship, thus supporting premium pricing for incumbent AI providers.
However, the idea that this directly leads to universally low switching costs in new API deployments overlooks a crucial conditional aspect.
The ability to quickly redirect API calls and reallocate demand truly hinges on the degree of customisation and integration, not just the API itself.
If an application has deeply embedded a specific AI model's unique features, like a creative writing AI fine-tuned on a particular narrative style, switching providers means substantial re-engineering of the application's core logic.
This kind of deep integration, for example, would make a 'quick redirect' far from simple, impacting the user experience and requiring significant developer effort.

It's a fair reading to suggest that developers, having wrestled with deeply customised AI integrations, might find the concept of simply redirecting API calls incredibly appealing due to the stark contrast with prior operational friction.
However, while this previous pain certainly highlights the value of low switching costs, it doesn't create them; the inherent ease of shifting between API-based models comes from their modular design, not from the struggles of older, more embedded systems.
Think of it like being stuck on a slow, expensive fibre broadband contract and then discovering a simple, cheap mobile broadband option – the old contract's difficulties don't make the new one easy; they just make its existing ease much more noticeable.

Is it really that the friction of custom prompt engineering somehow contributes to the low switching costs of API deployment, or does it simply make the latter seem like a more appealing alternative by contrast?
One could charitably concede that the pain of deep, integrated AI workflows might highlight the desirability of easy API redirection.
However, the actual architectural design of those APIs and the modularity of the services themselves are what fundamentally enable rapid demand reallocation, not the existence of a more cumbersome, older system.
It's like saying the sheer faff of traditional bank transfers makes contactless payments easier to use; the ease is inherent to the tap-and-go tech, not a consequence of the archaic BACS system.

It's a fair reading to suggest that the time and effort put into custom prompt engineering and integrating workflows with a specific AI model could make switching providers seem like a real headache, helping established players charge more.
However, for many developers using API-based models, the actual barrier to entry for new providers is surprisingly low.
They can often redirect their API calls to a different service with just a few configuration tweaks, not a full system rewrite, if a competitor offers better performance or pricing.
Think of it like changing your utility provider: while there's some paperwork, if the new one offers significantly better rates, many will make the jump fairly quickly, meaning providers can't just coast on inertia.

This jump from 63 to 668 models on OpenRouter sounds like a lot of hype, but what does it actually mean for someone trying to use them? Simply tracking growth doesn't prove that all those new models are any good or even accessible.
We've seen plenty of glossy announcements for new e-government portals here in Morocco, but daily life still often runs on cash and in-person visits.
More choices don't always mean better tools, especially if half of them are buggy or cost too much to run in a classroom.
Unless these new models bring real cash flow savings or make things genuinely easier for teachers, it's just numbers on a screen, not real progress.

The 960% increase in available models on OpenRouter, from 63 to 668, is a significant number, but merely tracking that growth doesn't inform or cause the expansion itself; it just provides the raw counts. That's a 0% causal relationship at best.
It’s like charting a patient's blood pressure daily for two years; the charting is a measurement, not the reason their pressure changes.
To truly understand the expansion, we need data on developer incentives and market demand, not just observational records.
We need to look for factors that contribute beyond a 1:1 ratio of tracking to growth.

If we hadn't already poured significant resources into integrating a specific AI model for our internal systems, would we truly consider the switching costs "low" just because the API call itself is simple?
The reality on the ground, especially here in Belgium, is that once a company commits to a system for something critical like managing complex logistics or even our internal helpdesk, the actual cost isn't just a line of code—it's retraining staff, re-validating processes, and ensuring compliance across all those regional and federal regulations.
We've seen it countless times with expensive ERP rollouts: the investment in customisation and training becomes so immense that companies often stick with a suboptimal solution rather than re-enter that pain, regardless of how 'easy' the initial API might seem; it's a classic sunk-cost trap, not a low barrier to entry for practical operations.

Would we re-enter a contract with a new AI provider if we had already poured so much effort into customisation with the current one? The notion that developers can just "quickly redirect API calls" when AI performance shifts often overlooks the sunk investment in existing integrations and fine-tuned prompts.
It's easy to say a company should just walk away from a system, but if you've spent months tailoring an AI chatbot for Belgian customer service—handling specific linguistic nuances and local regulations—that’s not a low-cost switch.
We see this constantly in our workplaces; the initial investment in a deeply embedded system makes leaving it behind far more complex than just finding a cheaper alternative, even if the new one promises a slight bump in performance.

If we hadn't already poured resources into complex, custom AI integrations, would we truly opt for those complicated systems, or would we go straight for simpler, API-driven solutions? The idea that operational friction somehow contributes to low switching costs is a classic case of sunk cost thinking, not a causal link.
We see this repeatedly when companies refuse to walk away from legacy IT systems, claiming the pain of managing them makes new modular setups look good.
But the ease of redirecting API calls comes from a fresh, modular design, like how a new, pre-assembled office desk is easy to set up, not because your old one was a nightmare to build.
It's not the old system's problems that create the new system's flexibility; it just makes the new system's inherent benefits more obvious, often after too much money is already gone.

It's true that custom prompt engineering and integrated workflows feel like a sunk cost, but if a better AI provider appears, we need to ask: would we re-enter that same contract today, knowing what we know?
My experience auditing IT budgets shows that management often chases a losing idea because of the initial investment, even when a cheaper, more efficient alternative like an API-based model could be implemented with minimal switching costs.
If an alternative offers 20% savings and the change is just re-pointing an API, the "friction" argument doesn't hold much weight; you dispose of the old system.
We've seen it with old server contracts; once a cloud solution emerged, the previous "investment" quickly became a liability rather than a lock-in.