Pick your models. Own your rails.

When you buy AI from a frontier lab, you think you’re buying a model. You’re not. You’re buying a bundle: the weights, plus the confidence that the model is safe and behaves the way you expect, a dashboard that tells you what you spent, and limits that stop one runaway job from burning the month’s budget overnight. The model was the part you were shopping for. The rest came with it, and you never had to think about it.

That bundle is coming apart. Over the past year the rational way to run AI stopped being one frontier API and became plural - a frontier model where the ceiling matters, cheaper open models for the bulk of the work, fine-tunes on your own data, some of it on hardware you own. Every step toward that freedom drops a piece of the bundle you didn’t know you were relying on. The models are getting easier to swap and the accountability is getting left behind. Your models will change constantly now. The layer that keeps you answerable for them shouldn’t - and it can’t come from the people selling you the models.

The single-model world is already ending

Using AI at work used to mean picking a side. You went with Claude or ChatGPT, your company standardized on it, and all of your AI work ran through that one model. There was no reason to want it any other way: one vendor to trust, one bill, one place to look.

That era is closing. For the past six months I’ve watched the leading edge of AI adoption pull away from the single-model world, on our own team and across the teams we talk to, and the direction is one-way.

At Constellation, the shift happened on its own. People in product, marketing, sales, and finance picked up ChatGPT, then discovered what Claude Cowork could do, and now they’re launching their own sites on Lovable or vibe-coding a personal project on the weekend. None of them are engineers - they’re just finding new ways to stretch what they can do with AI. They try whatever’s in front of them and keep whatever works, because they’ve gotten comfortable enough to keep reaching for more. The same pattern is showing up across most of the teams and companies we talk to.

The engineering teams are moving even faster and going farther. Nearly everyone runs several AI subscriptions at once, each for a different job: one to write code, another to review the code the first one wrote, a third to smooth out the workflow around them. The use cases keep multiplying - a frontier model where the reasoning is genuinely hard, a cost-optimized model serving inside a product, an open-weight model fine-tuned to excel at one specific task. Engineers are more capable than they’ve ever been, and we’d rather support workflows like these than restrict them.

Plenty of companies are already on this path. The ones that aren’t will be scrambling to catch up soon, because standardizing on a single frontier provider has stopped making sense. Matching the tool to the job is ordinary judgment everywhere else in a business - AI was the exception only because, for two years, the frontier was the only game worth playing. That exception is over, and the economics are closing it faster every month.

The frontier is becoming premium and metered

If you pay for Claude, you watched a piece of this happen in your own account. Claude Fable 5 - probably the most capable model anyone has shipped - arrived on June 9 inside the paid plans. Three days later, a US export-control directive switched it off for everyone. It came back with tighter usage limits. And Anthropic has announced that Fable will leave the flat-rate plans entirely: once that happens, Fable is metered, billed at the same rates developers pay, on top of what the subscription costs.

For anyone paying by the token, the economics of the frontier are getting harder to manage. Fable launched at $10 per million input tokens and $50 per million output, exactly double Opus 4.8. Its new tokenizer counts roughly 30% more tokens for the same text, so the effective increase is larger than the rate card shows. Running it US-only adds another 10%. And the volume is real - I’ve had days where I personally pushed more than 500 million tokens through these tools. At frontier prices, days like that get expensive fast.

I want to be fair to Anthropic here. Every one of those decisions is defensible on its own. Demand at the frontier genuinely outruns capacity, and they’ve said they want Fable back inside subscriptions once they can serve everyone; I take them at their word. But the trend is the same either way: you’ll reach for a frontier model when a task genuinely demands it, and the price will keep you from making it your default.

The open tier caught up

The saying used to be that open-weight models - the kind you can download and run yourself - ran about six months behind the frontier. This generation is proving that wrong. The best of them are genuinely capable and cost-optimized, and for plenty of jobs they’re the right choice over a frontier model rather than a compromise. The market has already turned: open-weight models now account for the majority of tokens routed through OpenRouter - about 60% over the past month, up from roughly a third late last year. And 81% of enterprises now run three or more model families in testing or production, up from 68% a year earlier.

Frontier models still make sense for the hardest problems - debugging that spans a whole codebase, or the kind of reasoning where one early misstep quietly breaks everything after it. That’s where Fable and the other top closed models earn their price, and where you should keep sending that work. But be honest about how much of what you do is actually that hard. Most of it isn’t - the everyday drafting and routine code that fill most of the day run just as well on a model that costs a fraction as much, from the fast-growing set you can now download and customize yourself.

Run one job through each and the gap is obvious. A million tokens read and a million written - roughly a medium-sized bug fix or a small feature - costs about $60 on Fable. The same work is about $4 on GLM 5.2, an open model that matches Opus 4.8 on coding and agentic tasks. On DeepSeek V4 Flash it’s twenty-seven cents. Flash is cheap enough that a single agent request costs a few hundredths of a cent, and that changes what you build: you stop rationing calls and start spending them.

The ways people put these models to work are multiplying too. Self-hosted agent frameworks like Nous Research’s Hermes let someone who isn’t an engineer run a capable agent they actually own - pointed at a cheap open model like Qwen 35B, living on a $5 server or the machine under their desk - instead of renting the whole workflow from a platform. Inside your own software, the assistant and the chat box are increasingly powered by an open model picked for cost rather than whatever a single vendor ships. Some of it runs on hardware you own, a Mac Studio or a DGX Spark on a desk, though most of it just points at a cheaper provider. Either way, the model is now something you pick for the task in front of you and swap whenever the economics change. The common thread runs through all of it: intelligence has become something you choose per task, rather than one provider you commit to for everything.

You only notice the rails when you leave them

This is the part that’s easy to miss. The rails from the opening - the confidence the model was safe, the spend limits, the dashboard - only become visible when you leave them. And every step into the multi-model world leaves one behind. Add a second provider and the record of what your agents did splits across two consoles. Deploy an open model and there’s no trust and safety team anymore; it’s your name on the deployment. Fine-tune a model on your own data and you’ve built the most valuable model you own, wrapped in none of that scaffolding - no dashboard, no screening on the way in or out, no record of what it did. The capable middle of the market gets better every month, and it ships with far less of this than the frontier you’re leaving.

And even the frontier’s rails were never really yours. The filters are tuned to the lab’s liabilities, not your risks. The records live in the lab’s console, in the lab’s format, for as long as the lab cares to keep them. Run six models and you get six dashboards and six half-overlapping definitions of safety - and no single answer to the question that matters at the end of the week: what did my agents actually do?

Every shift forces a new layer

Every major shift in computing commoditizes one layer and forces a new one into existence. When servers became rented compute, running fleets of them became its own discipline. When money moved online, payments stopped living inside each bank and became a layer of their own, with screening and limits that work the same across every bank on earth. Intelligence is going through that shift now: it’s becoming something you choose per job, from a catalog that changes every month. The layer it forces into existence this time is accountability - one place that stays answerable for every model you run, whoever built it and wherever it runs.

That layer can’t come from the model vendors, for three structural reasons:

• Coverage. A vendor’s controls see only its own traffic, so the moment you add a second model, every limit and guardrail you have becomes partial.
• Churn. Models are now the most frequently swapped part of the stack, and switching one should take minutes, not a migration of your budgets and rules and records.
• Neutrality. A vendor optimizes for its own margins, not your bill. It has no reason to route you to a cheaper model or trim the tokens you spend with it.

Your models will change. The accountability layer above them should not.

We built a layer

That layer is Gate: one accountability layer in front of every model you use, so the parts you actually have to manage live in one place instead of scattering across every provider you touch.

When we built Gate, we made one decision before any other: no walled garden. We don’t sell a model, so we have no reason to steer you toward one. Everything above stays identical whether you’re running a frontier model, switching to DeepSeek Flash to cost-optimize in production, or trying the latest image or video generation model - switch your setup every week and nothing above it changes. That neutrality is the whole point: an accountability layer works only if it sits above the models instead of belonging to one of them.

Cost is the part most people feel first. You set spending caps that hold across every provider, and Gate compresses what it passes through, trimming the tokens each call spends - on real workloads that’s 20% or more straight off the bill. Security runs on both sides of the call: prompts screened for injection on the way in, responses scanned for leaking credentials and personal data on the way out. Access stays yours: bring your own provider keys or run on ours, and every model sits behind the same endpoint, so swapping one for another changes nothing else. And every request and response lands in a tamper-evident record, so when you need to know what an agent actually did, the answer holds up.

If you write code, pointing your stack at Gate is a one-line change. If you don’t, Gate Connect is a small menu-bar app: sign in, switch it on, and the agents you already run on Claude Cowork, Claude Code, Codex, or Gemini are covered. It’s free to start.

I wrote in May about the week the floor shifted under how we build software, and why we built Gate in response. This post is the second half of that story. Agents crossed the threshold where they could do real work. Now models are crossing the threshold where you choose how that work runs - which model, whose cloud, at what price, and eventually, we think, on hardware you own. Our job is the accountability layer that keeps that choice usable: one place to hold your costs, your security, and your access while everything underneath keeps changing.

Pick your models - they will keep changing. Own the rails they run on.