At the end of March, my OpenClaw setup hit an awkward wall.

For a while, Anthropic OAuth access had been good enough for day-to-day agent work. Then access tightened. I do not mean “the model got slightly slower” or “one request had to retry”. I mean the system became unreliable enough that I was pushed toward the API path.

That sounded fine in theory. In practice it turned the assistant from a predictable tool into a metered engineering problem.

The API Was Not Just Pay As You Go

The frustrating part was not paying for intelligence. I am fine with that. A personal agent is only as useful as the model underneath it, and I have written before that the model matters.

The problem was the shape of the access.

Anthropic API usage had limit stages. At the beginning, those limits were tight enough that OpenClaw kept running into throttling during normal work. To move to the next stage, I had to spend money first. So the deal was effectively:

  • start with limits that are too low for a real agent workload
  • spend through the initial tier
  • get advanced only after proving usage
  • keep paying while discovering whether the new limits are enough

That is a reasonable system for fraud prevention and capacity management. It is also annoying when you are trying to run a personal assistant that should be boringly available.

Agents are not chat demos. They read context, inspect files, call tools, retry failed paths, and sometimes carry a heavy session because the real world has not been neatly compressed for them. If the provider limit shape is too tight, the assistant stops feeling like an assistant and starts feeling like a quota negotiation.

Cached Tokens Still Cost Money

The second irritation was cached token billing.

Caching is useful. It reduces latency and infrastructure waste. But from the user’s side, the emotional experience is simple: the same recurring context keeps appearing in agent runs, and the bill still moves.

That is not necessarily unfair. Providers have real costs. But it changes the psychology of the system.

With a personal agent, there is a constant temptation to make the workspace instructions richer: more memory, better routing rules, fuller safety boundaries, clearer personality, more local knowledge. Those instructions are not decoration. They are how the agent behaves properly.

If every run makes you wince at the context cost, you start shaving the wrong things.

You shorten the operating instructions. You hesitate before adding useful memory. You route work away from the strongest model. You begin designing around the bill instead of the assistant’s behaviour.

That is backwards. The economics should support the operating model, not quietly deform it.

The Monthly Cost Was Getting Silly

By the time I had a working Anthropic API setup, the monthly cost had crossed GBP 100.

That was not for a public SaaS product. It was for my own assistant: Telegram workflows, GitHub/blog work, local automation, health summaries, finance checks, Raspberry Pi diagnostics, and the general messy business of being useful across a real workspace.

GBP 100+ per month is not catastrophic if the value is high enough. But it changes the threshold for casual use. You start thinking before asking. You stop giving the assistant small jobs. You turn a tool that should remove friction into one that adds a small accounting voice in your head.

That is a bad sign.

The best personal automation disappears into the background. It should be easy to ask for a small thing, because small things are where a lot of the value lives.

Moving to OpenAI GPT-5.5 via Codex OAuth

In May, I switched the interactive OpenClaw path to OpenAI GPT-5.5 through Codex OAuth.

The difference was immediate.

No constant throttling. No dance around early API stages. No feeling that every useful bit of persistent context was a liability. For my workload, it simply worked.

The financial difference was even clearer: I went from more than GBP 100 per month on Anthropic API usage to GBP 20 per month for a standard ChatGPT subscription.

That is not a small optimisation. That is the difference between “this is a hobby infrastructure bill I need to watch” and “this is a normal subscription for a tool I use constantly”.

More importantly, the assistant became easier to trust again. Not because OpenAI is magically perfect, and not because every limit vanished. The important part is that the practical limits stopped being the centre of the experience.

The model could just do the work.

This Is Not a Universal Verdict on Anthropic

I am not claiming Anthropic is bad. Claude models are strong, and for many workflows the API may be exactly the right choice.

This is a narrower point: for my OpenClaw setup, at that moment, Anthropic’s access and billing shape was a poor fit.

The workload looked like this:

  • interactive personal agent use
  • rich local instructions
  • tool-heavy sessions
  • frequent small requests
  • occasional large context
  • a human who wants the assistant to be available without thinking about quotas

For that shape of work, generous OAuth access matters. Predictable subscription economics matter. Not being throttled during normal use matters.

Benchmarks are useful, but they do not capture the moment when your assistant says, effectively, “I cannot help right now because you have annoyed the quota system again.”

That moment is where the product fails.

The Real Lesson

The move from Anthropic API to OpenAI GPT-5.5 was not just a model switch. It was an operating model switch.

With Anthropic API, I felt pushed toward managing limits, stages, cache costs, and spend. With OpenAI via Codex OAuth, I could go back to managing the assistant itself: better instructions, cleaner memory, safer workflows, sharper automation.

That is where the attention should be.

For personal AI agents, the best provider is not always the one with the most impressive isolated answer. It is the one that lets the agent stay useful under normal, repeated, slightly messy daily use.

In my case, that meant moving to OpenAI GPT-5.5.

The boring outcome is the important one: fewer throttles, lower cost, and an assistant I can use without doing mental arithmetic first.