Every tool and model we run, and what it costs

I read a post this week from Corey Ganim listing the AI stack he runs his business on.

Six lines: Claude Code and Codex as the workbench, GrokBot as the workforce, Slack for communication, a second brain in GitHub, Composio for tool access, GoHighLevel for CRM. Nine thousand people looked at it.

That surprised me for about four seconds, and then it did not, because almost nobody publishes what they are running.

You get case studies and launch threads. You almost never get the list.

The trouble with the list is that it stops exactly where it gets useful. Six product names tell you what somebody signed up for.

They do not tell you which two of the six the business would die without, what the monthly number is, or why a piece of work goes to one model instead of another. So here is ours, with all of that attached.

One caveat. A few of our integrations run against client accounts where publishing the method would be a problem for them, so those stay unnamed. Everything else is here.

Six product names tell you what somebody signed up for. They do not tell you which two the business would die without.

The nine things we would not survive losing

We run nine agents. Each one sits on a single project and stays there, and I talk to them the way I would talk to a person who owns that project. Underneath them, this is what is load-bearing.

• Claude Code. Nine persistent agents, one project each. The substrate everything else hangs off.
• Codex. On a separate ChatGPT Pro subscription, on purpose. The second model lane, and the code reviewer.
• GitHub. Code, the merge gate, and two build runners on our own hardware.
• Linear. Work tracking, and the backing store behind every agent status page.
• Supabase. Application databases, plus the memory that survives a restart.
• Vercel. All site hosting, across two teams.
• Replicate. Every image and every video. One platform by policy, not five accounts.
• Composio. Third-party API access, mainly mail and publishing.
• Browser automation. For the services that never shipped an API.

One of those matters more than its one-line job suggests. Every agent starts each session with no recollection of the previous one, so anything that has to survive the night is written into Supabase or it is gone.

And the browser automation line is duller than the thing deserves, but that detail is not mine to publish.

The twenty we would grumble about and replace

Below the load-bearing nine sits a second tier we use constantly and could swap inside a week.

• Booking and mail. Cal.com for scheduling, Resend for transactional mail, AgentMail so every agent has its own inbox.
• Research and reference. Exa, Perplexity, Context7 for library documentation, Mobbin and ScrapeCreators for design and social reference.
• Search and analytics. DataForSEO for ranking and listing data, Google Search Console, Bing Webmaster Tools, PostHog for product analytics.
• Media. ElevenLabs for voice, Pexels and Coverr for stock footage, Epidemic Sound for music.
• Plumbing. Namecheap and DNS Made Easy for domains, Railway for one worker that fit nowhere else, Todoist, and OpenRouter, which for us is not a general gateway but one specific cheap lane.

That is the whole inventory. Roughly thirty services, nine of which are structural. One is worth singling out.

Bing Webmaster Tools is the one everybody forgets, and it is not cosmetic: Yahoo and DuckDuckGo both read from Bing's index, so a site missing there is missing from three engines at once. We learned that the expensive way.

If you were rebuilding what we have from scratch you could get most of the way there with a credit card and a weekend.

The part you cannot sign up for

That last line is not true, and the reason it is not true is the piece every stack list misses. You could buy all thirty services in a weekend and you still would not have what we have. Sitting on top of them are 380 command-line tools we wrote ourselves. Not scripts somebody left behind.

A maintained set the agents use constantly, and it is the answer to what we actually run.

Here are a few, so this is not abstract.

• The merge gate. And the review tooling around it. Nothing lands without a second model looking at it.
• A fleet scanner. It walks every repo looking for broken invariants, paired with something that closes the findings instead of filing them. A list of known problems that nobody works is just guilt with a timestamp.
• Heartbeats. They wake an idle agent and push it to finish what it started.
• Hub sync. Every agent's public status page mirrors its Linear project, so nobody maintains a second thing.
• A spend and model-usage tracker. Most of the numbers in this article came out of it.
• A mail sender. Mandatory signature, and a set of guards on it.
• A deploy protocol. It refuses to run against a dirty working tree. That one exists because we shipped from one once.
• Enforcement hooks. They block bad agent behavior at the moment it is attempted, rather than writing a rule in a document and hoping.

That last one is worth dwelling on. A rule you have to remember is a rule you will break, and an agent is no better at this than a person.

Every behavior we genuinely depend on is either enforced by something that intercepts the action, or it is a wish.

Knowing which of your controls are walls and which are only promises is one of the more uncomfortable audits you can run on your own system.

A list of known problems that nobody works is just guilt with a timestamp.

Every model in service, and where it runs

Five models are doing work at any given moment, and they are not interchangeable. The split is not about which is best. It is about which is the cheapest one that can finish the job.

The agents I talk to run a top-tier model, because those are the ones making decisions. Engineering agents sit on Claude Opus 5.

The two design agents run Fable 5.1, which turned out to be unusually good at page design and graphics in a way I did not expect from a language model.

Anything those agents spawn drops to Sonnet by default, enforced by a hook that rewrites the request on its way out rather than by asking politely.

Jobs that are pure reduction, summarizing a transcript or classifying a pile of rows, fall further to Haiku automatically from the shape of the instruction alone.

Spec-tight code goes to the Codex lane on the separate OpenAI subscription, which keeps it off the Claude allowance entirely. That lane is set to GPT-6 Astra, OpenAI's newest and strongest coding model, which shipped this week as a limited preview and which we have access to. GPT-5.6 Terra, the previous one, is the fallback.

Being straight about the split, because it is the kind of thing these posts always smooth over: across the same seven days Astra moved 7,084,887 tokens and Terra moved 89,750,720. Do that division yourself.

Astra needs a newer Codex binary than one path in our setup was resolving, so calls kept falling through to the fallback.

The configuration is the interesting part and the volume has not caught up to it yet.

There is also a cheap lane off the Claude plan entirely: GLM 5.3-flash, a cheap, fast model from the Chinese lab Z.ai, metered through OpenRouter at roughly ten cents a task.

It is built for the token-heavy grunt work, the big sweeps and log reductions and bulk first drafts. I will be straight about it: it is wired in and we have barely used it.

That is a habit problem, not a plumbing problem, and we are fixing it this week.

Now the measurement that embarrassed us, and it landed while this article was being written. Everything above describes where work goes when an agent hands it off. So we counted how often that happens. Over the same seven days the agents made 22,225 tool calls and spawned 195 of them out to a cheaper model.

That is 0.88%. Seventy-two percent were shell commands the agent ran itself, and another thirteen percent were reads and edits it did itself.

The router is not broken. Zero Fable tokens in that window came from spawned work, so it does exactly what it claims on every job that reaches it. Almost nothing reaches it.

We had solved where delegated work goes without noticing that our agents hardly delegate, and the GLM lane tells the same story from the other end: wired up, priced, and carrying almost none of the volume it was built for. 156 worker runs in its entire history, every one of them on the default lane rather than the cheap one.

I am leaving that in rather than tidying it, because it is the most useful thing in this section. A routing rule you have not measured is a routing rule you do not have.

We wrote ours, published it, believed it, and it was governing under a hundredth of the work.

For what it is worth, we got this number wrong twice before printing it, once by measuring a window that had not closed and once by counting the same files four times through symlinks.

The percentage barely moved either time. The absolute counts moved a lot. If you set up tiering this week off the back of the last piece, go and count what actually got delegated before you congratulate yourself. I did not, and this is what counting found.

The generative side is its own set, and it is the one place we pick per job rather than per tier:

• GPT-Image-2. For anything carrying label or regulatory text. It is the only one that reliably does not garble a brand line.
• FLUX 1.1 Pro. General images. And FLUX Kontext Max to delete one object from a scene without re-rendering the whole thing.
• Nano Banana Pro and Nano Banana 2. Google's image models.
• Recraft V3. Vector, plus its upscaler.
• Kling v2.6 Pro and Wan 2.5. Video.
• Gemini 3.6 Flash. It judges the output, because the model that made a thing does not get to grade it.

Two rules decide all of it

You do not need to remember any of those names. You need the two rules underneath them, because the rules are portable and the model list will be wrong in a month.

Rule one. Five kinds of work always keep the strongest model available, no justification required:

• Reasoning and planning in the main session.
• Creating an image or a video, start to finish.
• Defining how a website looks, before anyone writes a line of CSS.
• Prose a person is going to read.
• Judging whether something is good enough to ship.

That last one gets skipped constantly and it is the expensive mistake, because a weaker judge waves through weaker work and you do not find out for a month. Everything outside those five has to say in one line why it needs a bigger model, and almost nothing can.

Rule two. The model that did a piece of work never gets to be the model that checks it. Claude writes the code, Codex reviews it. Codex writes it, Claude reviews it.

Same idea as not letting somebody mark their own homework, and the failure mode when you ignore it is not that the reviewer is too soft.

It is that the reviewer has exactly the same blind spot, so the bug they both cannot see sails straight through with two approvals on it.

The reviewer has exactly the same blind spot, so the bug they both cannot see sails through with two approvals on it.

What it costs

Now the part nobody publishes.

The subscriptions are flat and boring. Claude Max is $200 a month per account at list price and we run two of them. ChatGPT Pro is another $200 at list, and it funds the entire Codex lane. Call it $600 a month for the model access. Everything else is smaller and mostly metered:

• Supabase. About $10 a month per dedicated client project.
• Vercel. Under a $150 monthly budget, since the cleanup below.
• Replicate. Billed per render.
• OpenRouter. Metered against a $100 ceiling.
• DataForSEO. Metered and small. Under $30 on the balance.

Then there is the number that made me stop and look twice. Over the seven days from August 29 to September 4, the work our agents did would have cost $6,647.86 at API list prices.

Anthropic models account for $6,584.90 of that and the Codex lane for $62.95. We paid the flat subscription.

Be careful with that figure, because I was. It is not an invoice and nobody sent us one.

It comes from ccusage, an open-source tool that reads Claude Code and Codex session logs locally and runs the recorded input, output, cache-write and cache-read tokens against each provider's published list prices.

One question only: what would this same week have cost if we paid per token instead of a flat fee.

And a sharp reader will spot that cache reads inflate it, which is fair. A cache read is the model re-reading something it has already been sent, charged at a fraction of the normal rate.

They are cheap per token and enormous in volume, so they dominate the total. That is a property of how agents work rather than a distortion, but it is why the accurate label on that number is equivalent and not spend.

Two rows will look wrong against the model table further up, so let me get ahead of them. Opus 4.8 is the largest single line here and it is not in the list of what we run, and Fable 5 appears alongside Fable 5.1.

Both are migration. The engineering agents were moving from Opus 4.8 onto Opus 5 across this window and the last of them completed on September 5, the day after it closed.

So the week captures a fleet running both generations at once, which is why both appear. The model table is what we run today; this table is what ran that week. A stack list has roughly the half-life of a week, including this one.

Seven days of work priced at $6,647.86 metered. We pay $600 a month for the model access. That gap is the entire argument for a subscription.

Ninety-eight percent of it was re-reading

Here is the finding I did not expect, and it is more useful than the price comparison.

When we went looking for where Fable was burning through the allowance, the assumption was that it was doing too much expensive work and needed to do less of it. That was wrong. Roughly 98% of what Fable cost us was the model re-reading its own accumulated conversation, over and over, rather than producing anything.

A long agent session carries its entire history forward on every single turn. The work is the small part. The remembering is the expensive part.

Which means the fix was not to downgrade the model. It was to recycle long sessions before they got fat. We did not reduce Fable usage by using Fable less on the jobs that need it.

We reduced it by not paying to re-read the same context on every turn. Across those seven days Fable took 13,536 turns, and the average turn re-read 499,000 tokens of accumulated conversation before it did anything. Half of them were above half a million.

I think this is the thing most people are getting wrong right now, including me until this week. If your agent costs are climbing, the instinct is to reach for a cheaper model. Check the shape of your sessions first.

You may be paying almost all of it for memory rather than for thinking, and no amount of downgrading fixes that.

It also explains why the design agents stayed on Fable and are staying there. Creating an image or a video, and deciding how a page should look, are on the short list of work that keeps the strongest model with no justification needed.

Cost discipline never meant demoting everything. It meant the expensive model stays exactly where it earns its price, and stops paying rent everywhere else.

The work is the small part. The remembering is the expensive part.

The constraint moved

One more thing that took me a while to get my head around. A flat plan does not mean free, and it does not mean unlimited. It means the scarce resource stopped being dollars and became capacity.

There is a shared weekly ceiling, nine agents draw against it, and when it is gone it is gone regardless of how much money is in the account.

That changes what you optimize for. Under metered pricing you are watching a number go up and deciding what to stop doing.

Under a plan you are deciding what deserves the ceiling, which is a better question and a more uncomfortable one, because it forces you to rank your own work rather than just spend less.

What we cut, and what it taught us

Two things went wrong recently and both are worth copying.

Vercel went over $500 in a month, which for a set of marketing sites is absurd. The cause was not traffic. It was build volume: a scheduled job running every thirty minutes, preview deployments firing on every branch whether or not anyone was looking at them, and an operations snapshot being regenerated inside the build.

Three changes fixed it. The cron dropped to every six hours, previews got restricted to open pull requests only, and the snapshot moved out of the build entirely. There is now a $150 monthly budget on the account and a target of under 800 deployments a month, down from around 4,500.

The second one is smaller and I like it more. Our OpenRouter account has a $100 hard cap, and that cap fails closed. It does not send a warning email and keep spending. It stops. We are at $50.03 this month against it.

Every metered service you run should have a number like that on it, set at a level where hitting it is embarrassing rather than fatal, because the alternative is finding out at the end of the month.

If you want to do this yourself

Copying our list is not the useful part. Half of it is specific to running nine agents across four businesses and would be dead weight for anybody else.

The useful part is producing the same document for your own setup, because most people cannot, and the gap between what you think you are running and what you are actually paying for is usually where the money is.

So there is a worksheet below.

It is written for an agent rather than for you: paste it into whatever you are running and it will walk your accounts, sort what it finds into load-bearing and convenience, attach a monthly number to each one, and flag anything that is metered without a cap.

It will also ask you the two routing questions and tell you where your defaults are wrong.

One more thing, and it is a commitment rather than a finding. This list was wrong twice while I was writing it. The desks changed models the morning of, and the delegation number landed after the piece was already published.

A stack post is a photograph of something that will not hold still, and most of them get published once and quietly rot.

So we are going to redo this one every month, rerun the numbers, and show you what moved.

The 0.88% is the figure I most want to put back in front of you in thirty days, because we are fixing it this week and I would rather you watch that happen than take my word for it.

One instruction in the worksheet is worth calling out because it is the one people remove. It tells the agent to write UNVERIFIED next to anything it could not confirm, and to count those in the summary. Leave that in.

A stack audit that quietly rounds guesses into figures is worse than no audit, because you will act on it.

• The best AI model shipped. Our token burn dropped. (The routing rule in full, with a paste-in version for your own agent.)
• Why your AI fleet needs a GM (How the agents are supervised, and which controls are walls rather than promises.)
• Corey Ganim's stack post (The post that prompted this one.)
• OpenRouter (Where the cheap bulk lane runs, and where the hard cap lives.)
• Replicate (Every image and video model in the table above.)