For as long as there have been AI models worth using, I have been running the same work through several of them at once. Not as an experiment. On any given task one of them was clearly better, and it was rarely the same one two weeks running.

Past a certain point, that stops being a habit and becomes a system you are running badly, by hand. So I built the system. It is called Layer Cake, and this note is about the labs inside it and the way it decides.

People ask which labs are behind myOrbit more than they ask almost anything else, and the question usually carries a second one. Is this an open-weight model running somewhere cheap? A lab whose rules nobody has read? So, the straight answer first.

The labs

The language models behind myOrbit — the part that reads, reasons and writes — come from four labs.

  • Anthropic, OpenAI and Google power Aura and Echo OS.
  • xAI powers some avatars, alongside the other three.

That is the same list as the one on our privacy page, which is where it is legally owed. It had better be the same list. A note that told you something different from the contract would be the worst sentence on this site.

We are evaluating xAI for Aura and Echo OS. If it holds up on our own production work, it gets added there. Neither is built on it today.

There is no self-hosted open-weight model behind these conversations. Why I declined to run one is a note of its own.

The rest of the stack is on the same privacy page, and I would rather point at it than paraphrase it loosely. Web search for research features runs through SerpAPI, Perplexity and Exa. Replicate runs image and media generation. ElevenLabs generates voices. Each does one specific job. The reasoning comes from the four labs.

Every lab’s agent runs on that lab

The labs have all built serious agents. Anthropic’s Claude Cowork takes a goal and “works across your files and tools.” OpenAI’s ChatGPT Work, launched on 9 July, is an agent “designed to execute tasks across different applications and files.” xAI’s Grok Bot is “your team of always-on agents,” and its page says it is built with Grok.

These are good harnesses: the scaffolding that turns a model into something that does work. Each is built around its maker’s own models, which is exactly what a lab should build. This note is not about harnesses, though. It is about what sits inside them.

Because they leave a question no lab has a reason to ask on your behalf. Models vary, task by task and person by person. So when you are paying for the work, why would you want every job done by one lab’s models?

Most routers are built to save money

Moving work between models is not new, and most of it is built around cost. That is a reasonable goal, and I want to be fair to it.

OpenRouter, which gives developers one endpoint for many models, balances traffic by default by “prioritizing price,” choosing among stable providers “weighted by inverse square of the price.” The research leans the same way. RouteLLM chooses between a stronger and a weaker model, “aiming to optimize the balance between cost and response quality.” FrugalGPT learns “which combinations of LLMs to use for different queries in order to reduce cost and improve accuracy.”

For a neutral gateway serving people whose work it cannot see, price-aware routing is the right default. It is the wrong default for a product that knows who it is working for.

Layer Cake starts with the person

Layer Cake puts the priorities in a different order. The first question is not which model is the cheapest one that will do. It is what this person needs from this piece of work, and which model is best at giving it.

That question has two halves, and they are different problems.

Which model is best at a kind of work is a question of capability, and it has no permanent answer. The team behind RouterBench starts from the observation that “no single model can optimally address all tasks and applications,” and the leader moves with every release.

What a person needs is a question of alignment, and people genuinely differ. The researchers behind PersonalLLM built their benchmark around “heterogeneous latent preferences,” departing from alignment benchmarks that “implicitly assume uniform preferences.” The routing field is beginning to say the same: the authors of Arch-Router argue that the benchmarks routers are judged on “often fail to capture human preferences driven by subjective evaluation criteria.”

At myOrbit, alignment to the person is what IntellectoAlign is for. Layer Cake places the work. How the two come together — the order of priorities, the decision itself — is the part I keep private. That the whole thing is organised around you rather than around the price of a token is not.

Cost still matters. It is just not first. One small rule shows the order: once a question has been judged to need deep reasoning, uncertainty about the details never talks the system down into a cheaper answer.

Routing was the foundation, not the pivot

Model routing has had a good year as an idea. In its 2026 AI and Automation FutureScape, IDC predicted that “by 2028 70% of top AI-driven enterprises will use advanced multi-tool architectures to dynamically and autonomously manage model routing across diverse models.”

Layer Cake went into the codebase in April 2025. The next month, model choice came out of individual prompts and into a task-based architecture, which is the decision everything in this note rests on. The dates are the claim, so I will just give them.

A router added to a finished product is a cost optimisation. A product built around one is a different product.

Where it runs today

In the Researcher, each part of a research question goes to the model best suited to it, across Anthropic, OpenAI and Google, and the claims are checked by a different lab from the one that wrote them. Deep research, built across AI labs is the long version.

In Aura, Layer Cake decides how much intelligence each turn needs before it answers. That exists to fix a habit. Someone picks the most capable reasoning model on offer, because why wouldn’t you, and leaves it selected for the whole session. It then spends the same deep, slow, expensive thinking on “what time is the dentist on Thursday” that it spent on the contract they asked about an hour earlier. Almost nobody switches down mid-conversation. Nobody should have to.

So Aura takes a fast path for quick things, a normal one for most of the day, and the deepest reasoning for the questions that deserve it. The saving is a side effect of fit: heavy reasoning on a light question does not produce a better answer, only a slower and more expensive one.

Every fallback chain in Aura crosses labs; nothing in it runs on only one. When a provider has a bad afternoon, the work moves to another lab instead of stopping. The unflattering edge of that, since someone will ask: if Anthropic, OpenAI and Google all go down at the same moment, Aura stops. I have looked at that case and accepted it.

Failover follows one rule that matters more than the rest. If a call fails because a provider is rate-limited or down, moving on is correct. If it fails because I sent a malformed request, it does not move on. Otherwise the fallback would hide my own bug behind a successful-looking answer, and I would watch the same defect fail identically across every lab while the dashboards stayed green. Better to fail loudly, once.

None of this asks you to pick a model. Why you never pick a model explains why that is deliberate.

Why quality decides

This matters more as the work gets more autonomous. If you are going to run agents, bots or twins, you want each one working with the best model for its job. Price is a real constraint, and Layer Cake respects it. But what decides whether people keep using something is the quality of what it produces.

Nobody has ever kept a tool because its failures were cheap.

What we publish, and what we don’t

This note used to say something different. When I first wrote about Layer Cake, I declined to name the providers behind it, and made a point of declining. That changed in September 2026, for a plain reason: people kept asking which labs we use, and the answer turned out to be one of the strongest things about the product. Keeping it private was protecting nothing.

Where the line sits has not changed. We publish which labs we use, and where. We do not publish how a request is broken into work, how a model is chosen for a given step, how those choices are weighed, or which model versions are in use at any moment. That placement is the hard-won part, and a public description of it is a specification for reproducing it. It also moves faster than a page can be kept true, and a stale page that people plan against is worse than no page at all.

The roster, not the routing.

Where this goes

Today, placement part by part goes deepest in the Researcher, and Aura routes on how much intelligence each turn needs. The next step is not live yet: the same placement reaching every surface, and more labs than these four. When it ships, it will ship as a note like this one, after it works. An external Layer Cake API is on the roadmap too, and the developers page is where it will appear first.

Labs will keep leapfrogging each other. myOrbit was built so that when they do, you do not have to switch anything.

References

Routing, and what it usually optimises

Preferences, and why one answer does not fit everyone

The labs’ own agents

Who handles what

Anthropic Anthropic OpenAI OpenAI Google Google