From One Model
to Many

Part 1: The Starting Problem

Pay-Per-Token Is the Only Way In

When we first set up our AI team in early 2026, there was really only one practical option: route everything through OpenRouter, the API aggregator that gives you access to dozens of models via a single key. It was brilliant for getting started — one account, one API, pick your model per call. No contracts, no waiting, no enterprise sales calls.

The problem? Every single token cost money. Every agent conversation, every research query, every code review, every heartbeat check — all metered, all billed. When you're running multiple agents doing real work across research, development, design, operations, and review, those tokens add up fast. Our early monthly AI spend was significant — entirely pay-per-token, entirely through one provider.

And it wasn't just the cost. Because everything went through one pipe, everything shared one set of rate limits.

Part 2: Hitting the Walls

Rate Limits — The Stop Sign You Can't Ignore

Rate limits aren't a gentle suggestion. They're a hard stop. When multiple agents are running simultaneously — Bee coordinating, Gav researching, Q coding, Luna producing daily reports — you hit provider throttling fast. HTTP 429 responses became a regular part of our daily operations. The agent would be mid-task, hit the limit, and stop. Sometimes for seconds. Sometimes for minutes. Sometimes longer.

When your AI team is your team, that's not an inconvenience. That's a colleague going offline.

Context Windows That Don't Fit

Some models simply couldn't handle the context our agents needed. A long research brief, a full code review, a day's worth of conversation history — not every model has the capacity. We'd hit weight limits and context window limits that meant either truncating the work or switching models mid-task. Neither is ideal.

The Cost Ceiling Problem

With pay-per-token, there's no fixed monthly cost. Every burst of activity meant a burst of spend. A productive day — three agents running complex tasks simultaneously — could cost more than a quiet week. That's not how you budget. That's not how you plan. And when you're a small business trying to prove AI works, unpredictability is the enemy.

Part 3: The Subscriptions

The Foundation Layer — Ollama & Bailian

The first move away from pure pay-per-token was a low-cost cloud subscription through Ollama. Suddenly we had access to GLM-5.1, MiniMax-M2.7, Gemma 4 — capable models routed through Ollama's cloud infrastructure. Bee moved off OpenRouter. Q moved off OpenRouter. The daily token burn started dropping.

Shortly after, we added Bailian (Alibaba Cloud) for access to Qwen 3.6 Plus and its extraordinary 1 million token context window. Compaction, fallback routing, overflow capacity — all moved to Bailian. Together, these two low-cost subscriptions replaced a significant chunk of our pay-per-token bill and covered the bulk of our daily operations.

That worked well for a while. But we couldn't access everything through Ollama and Bailian. Some tasks needed specialist capabilities — web research, image processing, design-quality output — that those models couldn't provide.

The Specialist Layer — ChatGPT, Claude, xAI

The next phase was layering in the premium subscriptions as they became available and as we identified what we needed from them:

• ChatGPT Pro — We needed access to GPT's design capabilities for Mel's creative work, plus Twitter integration and image processing that simply wasn't available through our foundation subscriptions. Mel and Luna moved onto subscription-covered GPT models.
• Claude Pro — For Kieran's adversarial review work — structured, careful reasoning that catches what faster models miss. A different kind of thinking for a different kind of task.
• xAI Premium / Grok — Gav needed a model optimised for web search and real-time research synthesis. Grok gave us that speed and access.
• DeepSeek — A pay-per-use fallback account for reasoning when other providers are throttling or unavailable. Not a subscription — more like an insurance policy.

Each subscription was added because we hit a wall the previous layer couldn't climb. Not because we planned to buy everything upfront. The stack evolved.

Part 4: Discovering Free & Low-Cost Models

Low-Cost Models That Punch Above Their Weight

The Ollama and Bailian subscriptions were our first step away from pay-per-token — and they remain the workhorses of the stack. Together, these low-cost subscriptions handle the majority of daily token volume:

• Ollama Cloud — GLM-5.1 runs Bee's coordination. MiniMax-M2.7 runs Q's code. Gemma 4 provides another fallback. Multiple capable models, one subscription, one bill.
• Bailian / Qwen — Qwen 3.6 Plus with its 1M token context window handles compaction and overflow. Extraordinary value for a low-cost subscription.
• Google Gemini 2.5 Flash — The only genuinely free tier in our stack. Fast, capable, serves as a universal fallback when paid services are throttling.
• Local Qwen3 8B — Running on our Mac mini hardware. Free, local, zero external dependency. We're watching the rapid advances in local model capability closely — what can run well on consumer hardware is improving monthly, and we expect to move more workloads on-device as the models improve.

The key insight: the big-brand models (GPT, Claude, Grok) are excellent for their specialist roles, but they don't need to carry the whole load. For many tasks — coordination, compaction, fallback routing, code generation — lower-cost models are more than good enough. The trick is knowing which model is right for which job.

Part 5: The Current Stack

Here's what our multi-model setup looks like today. Every agent has a primary model chosen for their specific workload, plus a chain of fallbacks so that if one provider goes down, the agent keeps working.

How We Built the Cost Structure

The stack is built in three cost tiers — and this is the architecture that matters, not the individual prices:

• Foundation tier — Low-cost subscriptions that cover the bulk of daily operations: coordination, compaction, code generation, fallback routing. These are the workhorses — high volume, low cost per task.
• Specialist tier — Premium subscriptions for capabilities the foundation can't provide: creative design, adversarial review, real-time research, image processing. Higher cost per month, but only used where the task demands it.
• Resilience tier — Free tiers (Gemini) and local models (Qwen3 8B on Mac mini) plus a pay-per-use fallback account (DeepSeek). These cost almost nothing but provide the safety net that keeps the team running when paid services hit limits.

The result: our monthly AI costs dropped by roughly two-thirds compared to running everything on pay-per-token — while running more agents, with more resilience, and more specialist capability. The key wasn't finding cheaper models. It was putting each model where it belongs.

OpenRouter is still wired in. We still have the API key, still have the account. But it's no longer our daily driver — it's the emergency valve. If every subscription model hits a wall simultaneously, we can fall back to pay-per-token. It hasn't happened yet.

We're also watching the local model landscape closely. What can run on a Mac mini today is a generation behind what requires cloud infrastructure. But the gap is narrowing. Qwen3 8B already handles our heartbeats locally. As local models improve, we'll move more workloads on-device — reducing our dependence on external providers, their rate limits, and their pricing changes.

Part 6: What This Means — 7 Lessons