Three Agents Walk into a Bar: My Experiment to Code More and Spend Less

There comes a time in every programmer’s life, when using coding copilots, where you look at your monthly bill and think: “This is great and all, but I have more subscriptions than my local gym membership.”

That moment came for me with quite a lineup: Claude Max 5, Codex Plus, and the temptation to throw in Z.AI with OpenCode for the grunt work. The idea sounded fantastic. The problem? If you throw three agents into your workflow with no ground rules, you’ll end up like a chaotic construction site boss—everyone scrambling around while no one holds the blueprints.

My initial conclusion is simple: before automating the routing, it’s a good idea to run a manual experiment. Just for a couple of weeks. Using simple, yet clear rules.

The Real Problem Isn’t the Price. It’s the Chaos

Paying 23 euros, 90 euros, or 10 dollars separately doesn’t seem like the end of the world.

The problem starts when all these tools get in each other’s way. You ask one agent to think, another to implement, then bring in the first to proofread, and finally a third to handle some grunt work. Twenty minutes later, you’re no longer sure if you’re optimizing for cost, quality, or just keeping yourself busy switching between tools.

In plain English: the real cost isn’t just the subscription. It’s the context switching.

This is like having a kitchen stocked with a Japanese knife, a Thermomix, and an air fryer. They’re all useful. They all do different things. But if you try to fry potatoes in the Thermomix, well… it’s not going to end well.

My Hypothesis: Think, Execute, Clear Out

The policy I want to test can be summarized in three lines:

• Claude for thinking
• Codex for execution
• GLM/Z.AI for clearing out

This isn’t some academic theory. This is a workshop rule.

When a task is poorly defined, impacts architecture, comes with risks, or requires judgment, the logical thing to do is hand it off to the agent that reasons best. In my case, that’s Claude.

When the task is already well-defined and it’s time to jump into the repo, edit files, run tests, and iterate over bugs, that’s where Codex comes in.

And when it’s time for that mind-numbingly repetitive work no one wants to do but someone has to—like simple tests, documentation, tiny scripts, renaming files, or mechanical refactoring—that’s the perfect moment to bring in GLM with OpenCode.

What I’m NOT Ready to Do Yet

I’m not going to set up an automatic router.

I don’t want some magic intermediary layer analyzing prompts, sorting tasks, picking providers, switching between models based on the hour of the day, and then producing a flashy dashboard for no reason other than the illusion of progress.

That sounds like a hilariously fun project. It also sounds like premature over-engineering.

The classic mistake here is building air traffic control before knowing if you actually have air traffic. First, observe. Then decide if putting in traffic lights is worth your time.

The Two-Week Manual Policy

The experiment I’m running is much less glamorous but probably way more practical.

1. Claude for Hard Problems

I’ll start with Claude if any of the following apply:

• I don’t know the best approach off the bat
• It requires design decisions
• There’s a risk of seriously breaking something
• I need to review logic or arguments, not just code

In human terms: if the task needs critical thinking, this is where I won’t try to save money.

2. Codex for Core Repository Work

I’ll use Codex when the task is already straightforward:

• Implementing real changes
• Fixing failed tests
• Refactoring with validation
• Iterating until the project is back in the green

This is where a good execution agent earns its keep—not because of the model itself, but because it seamlessly fits into the workflow.

3. Z.AI for Cheap, Replaceable Labor

The rule for Z.AI would go something like this:

• Boilerplate
• Drafts
• Documentation
• Simple tests
• Small scripts
• File renaming
• Easy-to-review mechanical changes

If it messes up, no big deal. Scrap it and retry with another tool.

That’s the key. I’m not giving GLM delicate, precision work. I’m asking it to crank out widgets.

The Most Important Rule: If It Fails Twice, Escalate

This is the part with the most value—and the part most people skip.

When a cheap tool fails, the temptation is to keep trying. “Just one more iteration.” “This time for sure.” “Let me tweak the prompt.” “I’ll add a bit more context.” And 30 minutes later, you find yourself trying to negotiate with the model like it’s some possessed HP printer.

Here’s the rule for this experiment:

• If Z.AI fails in 1-2 attempts, escalate:
  • If it’s an execution problem, send it up to Codex
  • If it’s a design or comprehension problem, escalate to Claude

Cheap stops being cheap once it starts stealing half an hour of your life.

What I Actually Want to Measure

I’m not interested in putting on a benchmark theatre performance.

I’m not going to whip up a table showing tokens per second, average latency, or other very serious-looking numbers—only to realize later my real issue was renaming 40 variables without killing an afternoon.

What I do want to measure over two weeks is this:

If this experiment works, great.

If it doesn’t, better to find out now with a $10 spin of the wheel than after building a mini-airport and installing a control tower.

Real, Not Hypothetical Tools

The affordable component of this experiment didn’t come out of nowhere—OpenCode exists and is built precisely to work with coding agents from the command line. Z.AI documents its coding plan and the use of its GLM models for coding tools.

That doesn’t mean I’m replacing Codex or Claude outright. It just means there’s a solid enough foundation to test it without making things up as I go.

Here are the official references I’ve checked to avoid spinning tall tales:

• OpenCode
• Z.AI DevPack

My Bet for Now

Right now, my plan is simple and far from epic:

• Keep Claude Max 5
• Keep Codex Plus
• Try Z.AI Lite for simple work
• Hold off on automating the routing (for now)
• Reevaluate in two weeks: does this actually reduce my costs, or is it just adding friction?

The mental policy fits on a sticky note:

If it’s unclear, Claude.
If it needs building, Codex.
If it’s grunt work, GLM.
If GLM fails twice, we’re done here.
---

Not fancy. No YAML. No MCP. No blinking control panel required. And that’s precisely why I suspect it’ll work.

Because sometimes the difference between a useful system and an unnecessary gadget doesn’t come from adding more intelligence.