Claude Fable 5.1 now ships in two tiers. OpenAI's GPT-6 Astra is next. We built a governance layer for the many-tiers era.

This week, Anthropic shipped Claude Fable 5.1 for general use while keeping Mythos 5.1 — the same underlying model with fewer safeguards — behind a vetted-access program. OpenAI is taking the same path with its forthcoming GPT-6 Astra, which reportedly crossed the highest risk tier in its own safety framework. Same model, multiple tiers of access: that shift quietly turns model selection into a credentials-and-routing problem.

We are a small team that spent the past few years inside the AI infrastructure mess, first as engineers building data pipelines, then as operators running model-heavy products for banks and research orgs.

Over the past year, we kept hearing the same story from engineering teams: "We have keys for four providers, nobody remembers who created half of them, and the invoice is somehow two departments' problem." Model selection was the part everyone talked about. The part nobody talked about was the plumbing behind it — who holds a key, which endpoint is allowed to do what, and why the bill keeps growing.

So we started talking to engineering teams that run more than one LLM provider in production, and asked three questions: how do you issue access, how do you track usage, and what happens when a key leaks or a budget blows.

Here is what we saw, again and again:

Teams routinely juggled keys across multiple model providers at once, and several ran far more distinct endpoints than anyone had tracked when you count tiers and regions.
A surprising share of issued keys were still active long after the person who requested them had left the company.
Spend attribution was guesswork. More than one team discovered live spend going to prototype projects nobody had remembered to shut down.
Every pricing change or model deprecation meant a code change and a fire drill — one vendor's price hike on a legacy model took weeks to fully remediate, because the old model name was hard-coded across multiple services.
And almost nobody could answer "who called this model yesterday and what did it cost?" without a days-long audit.

None of these teams were careless. They were moving fast on AI. The tooling just had not caught up. It was 2015-era database sprawl all over again, except nobody had written the equivalent of a proper control plane yet.

That is the gap we are filling with aikey: one control plane in front of every model endpoint you use.

The mental model is simple. Developers stop getting raw vendor keys. They get virtual keys that carry real policies:

A key is bound to a project, a team, a budget, and a list of allowed models. Issuing takes seconds; revoking takes one command, and it propagates immediately.
Routing happens at the layer, not in business code. Your app declares what capability it needs; the layer decides which endpoint and which tier serves it, and fails over when a provider rate-limits you or raises prices.
Every call is logged with structure: who initiated it, which model served it, the token count, the cost, and whether any policy boundary was tripped. No more month-end reconciliation by guesswork.
Runtime checks sit between your app and the provider: identity, prompt-level risk tiers, budget limits, and audit hooks. If a policy says this team may only use tier-one models, that is enforced at the gateway, not by a code review.

We deliberately did not build a "which model should you pick" recommendation engine. Model labs are better at that and it changes every month. We built the layer underneath: credentials, routing, budgets, audit. That layer is useful no matter which model wins the benchmark race next week.

The boring-but-important results from early customers:

Teams that could finally see which endpoints were serving which workloads cut spend quickly — in one case they had been paying premium tier for internal batch jobs.
Unexplained spend turned out to be a staging environment calling production-grade models around the clock. The team found it in one dashboard query, not days of log spelunking.
Audit requests that used to take days now take a single report.
Onboarding a new model provider went from a multi-week project to a configuration change.

The honest tradeoff: a governance layer is only as good as the policies you write for it. Teams that start with a skeleton policy set see the biggest wins; teams that expect the tool to magically know their budget structure take longer. We ship policy templates for common cases (per-team budgets, tier restrictions, staging vs production separation) to make the start fast.

Model generations are turning over faster every quarter. Whatever is strongest today will be mid-pack in a few months. And capability is only heading one way: more gated, more differentiated, more auditable at the provider level. The consumer side needs a matching layer, or the enterprise simply cannot say yes to the strongest models.

We think the layer that owns credentials, routing, and audit will outlive any single model vendor. That is the bet aikey is making.

If you manage more than one model endpoint, you probably have a version of this pain. We wrote about what we are building, including honest numbers and design tradeoffs, here:

https://aikeylabs.com/zh/i/ih36

Questions, feature requests, and war stories welcome: aikeyfounder@gmail.com