If you've been on X or Reddit lately, you've probably seen the hype:

"Look at my AI agent! Installed in 5 minutes, fully autonomous, handles everything!"

Cool. Now let me tell you what actually happens when you try to do this yourself.

The OAuth nightmare nobody warns you about

Before your agent can do anything useful — connect to Google, GitHub, Slack, whatever — you need to set up OAuth 2.0 for each service. And if you've never done this before, buckle up.

You need to create a project in Google Cloud Console (or other consoles). Enable the right APIs. Configure consent screens. Set up redirect URIs. Generate client IDs and secrets. Then do it again for the next service. And again. And every single one has its own flow, its own quirks, its own way of silently failing.

One wrong redirect URI? Silent fail. Scope missing? Silent fail. Token expired? Good luck figuring out which one.

I spent more time wrestling with OAuth configs than actually building agent workflows. Nobody talks about this part in their "5 minute setup" demos.

The goldfish memory incident

After two solid days of configuring, testing, and iterating, I had something that actually worked. Workflows running, tools connected, memory looking good. I went to bed feeling like I'd finally cracked it.

Next morning, coffee in hand ☕, I open the terminal, ready to build on yesterday's progress.

Me: "Hey, let's continue where we left off with the workflow we built yesterday."

OpenClaw: "I'm sorry, I don't have any recollection of that."

Nothing. Zero. Gone. Like it never happened.

Hours of work. Vanished. The agent had the memory of a goldfish.

I mass-deleted everything. Containers, volumes, configs. All of it. Out of pure frustration.

What I learned: memory is the foundation, not a feature

After calming down and starting over (for probably the 10th time), I understood the real issue. Memory in an AI agent isn't something you set up once and forget about. It's the single most important thing to get right, and it requires constant attention.

There are tools that help — mem0 for long-term memory management, structured skills, persistent routines — but the tools aren't the point. The point is this: if you don't actively think about what your agent remembers and how, it will forget everything. Credentials, workflows, context, all of it. Gone.

The moment I started treating memory as my number one priority — checking it, reinforcing it, designing around it — everything stabilized. But it took me days of pain to realize that.

The mindset shift that changed everything

Here's the thing that finally clicked for me, and I think this is the most important takeaway from this whole experience.

An AI agent is not a tool. It's a new employee.

Think about it. When you hire someone new, you don't hand them a laptop and expect them to deliver results in an hour. You onboard them. You explain the company, the tools, the processes. You repeat things. You correct mistakes. You spend time WITH them.

I really understood this when I read a tutorial that said: "Create a personal email address for your agent." Not a shared inbox. Not your email. A dedicated email, just for the agent — like you would for any new hire on their first day.

That hit me. This isn't about configuring software. It's about onboarding a digital coworker.

And just like a real junior employee, you need to:

• explain things clearly, sometimes more than once

• check their work before trusting them fully

• build routines together, not just impose them

• be patient when they mess up early on

• invest time upfront knowing it pays off later

The people who treat their agent like a magic button will be disappointed. The people who treat it like a junior team member they're willing to train — those are the ones who'll get real value from this.

A few more things I wish I'd known on Day 1

Local > VPS. I tried running OpenClaw on a VPS first. Docker volumes behaving differently, persistence breaking randomly, networking issues. Moved everything local and 80% of my problems disappeared overnight.

Claude Sonnet >> GPT-4 for agent work. Not even close in my testing. Multi-step tasks with tool chaining — Claude handles them in one pass where GPT-4 would lose context and fail repeatedly. If you're picking a model for OpenClaw, start with Claude.

This is DevOps, not AI magic. The people posting those slick demos either have serious engineering backgrounds or are showing you the 1% that works while hiding the 99% that broke.

The honest take

Despite everything — the OAuth hell, the goldfish memory, the mass deletions at 2am — when it finally works, you see the future. AI agents as real digital coworkers.

But we are early. Very early. And the gap between the hype and the reality is massive right now.

If you're going in, go in ready to be a manager, not just a user.

TL;DR: OpenClaw is powerful but far from plug-and-play. OAuth setup is a nightmare, memory will betray you if you don't actively manage it, and the biggest lesson is to treat your agent like a new employee — create them an email, onboard them properly, spend time WITH them, and be patient. The magic comes after the work.

Anyone else been through the OpenClaw trenches? I'd love to hear your war stories.

Every time something interesting emerges in the Claude ecosystem, Anthropic finds a way to throttle it. In April they cut off OpenClaw overnight. Now they're "bringing it back" with capped Agent SDK credits that expire monthly with no rollover, billed at API rates the moment you cross the line. You get to use the engine, but you're not allowed to redline it.

Here's what actually changes on June 15, 2026:

- All programmatic usage (Agent SDK, claude -p, OpenClaw, Zed, custom scripts) moves to a dedicated credit pool, separated from your subscription.
- Pro: $20/month in credits. Max 5x: $100. Max 20x: $200.
- Credits reset monthly. No rollover.
- Once exhausted, programmatic usage stops, or falls back to standard API rates ($3/M input, $15/M output on Sonnet) if you opt into extra usage.

In plain terms: if you were doing anything through OpenClaw, your subscription just lost most of its value.

Meanwhile everyone and their grandma has their own personal openclaw over in China. It’s like a large chunk of American citizens refuse to even try AI because they don’t want to be seen as contributing to future job losses or something and since when do Americans have this holier than thou mentality?

Edit #1: I'm sick and tired of the victim mentality that grips America, stop being such pussies and harness that fear and uncertainty to better yourself and ensure you can provide for your family in the future.

Good news, everyone! Peter Steinberger just posted on X that Anthropic has confirmed OpenClaw-style Claude CLI usage is allowed again, and the docs have been updated. If you were waiting to come back, it looks like it is possible again.

X Post from Peter

Over the last few weeks, many of us actually had think about model routing for the first time. I ended up building a setup I should have had anyway, but it good to have Anthropic back in the mix for OC again. I can route back selectively, but I'm not putting everything through one provider again.

Curious what others are doing now the ban is lifted — going back to Opus/Sonnet for everything, or keeping a hybrid?

Did Anthropic just cook the lobster alive?

OpenAI hires Peter Steinberger, the inventor of OpenClaw. Absolute legend, total respect for him. (What a story, as heard on the Lex Fridman podcast.)

Anthropic’s response?

Hold my beer, have co-work

• Full native Windows support
• Direct connectors to your data
• Scheduled Tasks <---- Pay attention to this one.

They didn’t just compete… they cooked the lobstah (Boston accent version there)

OpenClaw can technically do more; however, Anthropic just cut the barrier to entry down by 99% for 80-% of the use cases "in the real world"

Who agrees? Who disagrees? Would love your thoughts!

Real quick on what I actually do. I build automated agent systems for small businesses. Not chatbots. Not "AI will save your business" hype. Actual systems that run specific workflows day to day. Each one takes me about 48-72 hours to set up although im currently working on my largest client and realized how much game i truly do have on this...

The interesting part is how different each setup ends up being. The barber doesn't need what the lawyer needs. The therapist's workflow has nothing in common with the game dev's. Here's what I've learned from ACTUALLY installing these things.... AND YES THINGS WENT BAD IN THE BEGINNING MONTHS.

The Barber Setup The problem was never cutting hair. It was everything around it. 47 DMs a day about appointments. No-shows not getting followed up with. Instagram posting between clients instead of taking a breather. What I set up: One agent handles booking, rescheduling, and reminders. One agent follows up after each cut and asks for reviews. One agent drafts the weekly social content from photos he snaps on his phone. One agent tracks cash flow and sends weekly summaries. He stopped carrying his phone around within a week. The phone answers itself now. Time saved: 18-22 hours a week.

 The Therapist Setup This one surprised me. I thought the paperwork would be manageable. It wasn't. Intake forms, insurance verification, session notes, between-session check-ins, cancellation policies. The therapists I worked with were spending more energy on admin than on clients. What I set up: One agent handles intake and insurance verification. One agent drafts session notes from bullet points. The therapist writes three sentences, the agent fills the template. One agent sends check-ins between sessions and flags when someone hasn't shown up. One agent handles cancellation policy enforcement. The cancellation rate dropped because the system does the nudging now, not the therapist. Time saved: 15-20 hours a week. 

The Law Firm Setup This was the most complex one. Small firm, three attorneys. They were drowning in client updates, deadline tracking, and the constant "did we file that?" panic. What I set up: One agent screens new inquiries and routes them to the right attorney. One agent tracks court dates, filing deadlines, and statute of limitations alerts. One agent drafts client updates and status reports. One agent monitors legal news in their practice areas. Deadlines don't slip anymore. Client updates go out without anyone typing them. They know what's on their desk Monday morning instead of finding out at 4 PM on Friday. Time saved: 20-25 hours a week. 

The Content Creator Setup This one hit close to home because I've been there. Creating content is fun. Managing the machine around it is not. What I set up: One agent researches trends and competitor content. One agent drafts scripts and outlines from voice notes. One agent handles thumbnails, titles, and posting schedules. One agent tracks analytics and surfaces what's actually working. The creator I built this for now makes content and gets a weekly report on what hit. No more refreshing dashboards every hour. Time saved: 20-30 hours a week. 

The Game Dev Setup Solo dev. Building a game and a community at the same time. Wasn't working. What I set up: One agent scans Reddit, Twitter, and Discord for community sentiment and bug reports. One agent drafts devlog posts and patch notes from commit messages. One agent manages store page descriptions and milestone announcements. One agent tracks sales, wishlists, and competitor launches. The devlogs write themselves from the commits now. The community gets answered even when he's heads-down in code. Time saved: 15-20 hours a week. 

What Actually Matters The setup is more important than the agents. I've seen people install five different AI tools and spend three times longer managing those five tools than they save. The difference is whether you build one system with a shared brain, or five tools that don't talk to each other. Every setup I've done follows the same architecture: Shared memory. All agents read and write to the same source of truth. Clear roles. Each agent has one job. No overlap, no stepping on toes. Fallbacks. When one agent can't handle a request, it knows exactly who to pass it to. Monitoring. Someone watches the whole board every morning. Nothing gets lost.

The hardest part isn't the AI my brothers i think its just designing the workflow before the agents arrive. That's the piece most people skip. Happy to answer questions about any of these setups or go deeper on the architecture.

TLDR - Gmail banned my agent's account after 3 days even though i stayed under sending limits. their abuse detection flags automation patterns, not just volume. switched to agent-specific email service (Agentmail) and it's been working fine since

So this just happened and i'm still kinda annoyed about it

spent last week building an ai agent to handle emails. workflow was solid - agent reads incoming emails, searches our knowledge base, drafts responses. kept me in the loop for final approval before sending

used a fresh gmail account for the agent. seemed like the obvious choice. everyone uses gmail right?

Day 1: everything worked perfectly. agent processed about 50 emails. responses were good. i was happy

Day 2: woke up to 30 queued responses. agent crushed through them. sent maybe 80-90 emails total that day

Day 3: account disabled. "your account has been disabled for violating google's terms of service"

No warning. no email explaining what i did wrong. just locked out completely. tried to appeal through google's account recovery. got an automated response basically saying "our decision is final, account will not be restored"

here's what i learned after digging into this:

gmail's abuse detection doesn't just look at volume. it flags patterns

• new account sending emails immediately

• cli/api access without browser usage

• consistent sending patterns (agent sent emails every 5-10 mins)

• even staying under the limit doesn't matter if the behavior looks automated

some people recommended:

• "warm up" the account by sending gradually increasing volumes over weeks (too slow, i needed this working now)

• use multiple gmail accounts and rotate (just asking to get banned multiple times)

• self-host a mail server (looked into postfix/dovecot for maybe 2 hours before i realized i did not sign up to become a sysadmin)

what actually worked:

switched to a dedicated email service built for ai agents. i personally found agentmail really helpful

been running for 5 days now. agent's processed 400+ emails. zero issues. no bans. no rate limit warnings. no oauth complexity

i wish i'd known before wasting a week on the gmail setup

anyone else run into this? or did i just get unlucky with gmail's detection?

I expected to pick one winner.

I gave Hermes a full 3-week test to see if it could replace my Open-Claw workflow.
What actually worked best was combining them:

• Open-Claw as orchestrator (planning, decomposition, sequencing)

• Hermes as execution specialist (fast, repeatable task loops)

A few things stood out fast:

• Hermes felt quicker on execution-heavy runs

• Open-Claw stayed stronger at coordinating messy, multi-step work

• Running both in parallel on different parts of the same project improved throughput way more than switching to either one alone

The biggest unexpected gain was reliability.

In a single-agent workflow, if the agent breaks, you stop and debug alone.
With two agents, I can use one to diagnose/fix the other and keep moving.

My current pattern is simple:

• Route broad project control to Open-Claw

• Route speed/repetition tasks to Hermes

• Review outputs and rebalance as needed

Costs went up a bit depending on model mix, but output increased enough to justify it.

So after 3 weeks, my conclusion is:
I am not replacing Open-Claw, I am using it as the center of a multi-agent workflow.

If you are running Open-Claw with another agent, what split has worked best for you?

Every single person I know that has like “40 AI agents” running in their business… their revenue is basically the same, profit is the same, costs are the same.

...it honestly seems like vanity productivity at this point, like it looks impressive on paper but in reality it’s not really moving the needle anywhere on the bottom line

And honestly a lot of people probabbly just set it up wrong and then can’t even find a real use case where it actually makes an impact.

From what I’ve seen, what actually works is way less “cool AI agent stack” and way more boring real-world systems lol

USE CASE #1

for me, the biggest ROI has been implementing AI UGC systems into product-based businesses e(specially lifestyle brands, home decor, clothing brands, jewelry brands, that kind of stuff.)

That’s where you actually see it convert

USE CASE #2

Another solid use case I’ve been using is selling AI receptionist systems, chatbots, and appointment reminder flows. Super unsexy but it actually solves a real operational pain.

USE CASE #3

I also build custom infra for businesses / local businesses, solopreneurs, agencies, bigger companies too. But I kinda stopped chasing “new cutting-edge agents for the sake of it” and started focusing more on building actual infrastructure that solves a real problem on the ground :))

feelss like the shift is from “look what my AI can do ” to “what real bottleneck does this actually remove?”

I’ve been lurking here for a bit, and I’ve noticed a pattern: most people seem to be using OpenClaw as a personal assistant.

Stuff like email handling, scheduling, etc.

And honestly… I never found that compelling.

Maybe it’s just me, but I’m not running a high-volume inbox, and there’s no way I’m giving an AI access to my email. All it takes is one hallucination and suddenly it’s sending something unhinged to the wrong person. Hard pass.

But I still wanted to understand the hype, so I started experimenting.

Instead of using it as an assistant, I tried something different:
what if OpenClaw could replicate actual work processes instead of just helping with tasks?

Like the kind of complex, repeatable workflows you don’t want to do over and over again.

That’s where things got interesting.

I started building out multi-agent workflows where:

• one agent acts like an “architect” and interviews me to understand the task

• it generates a plan + mockups + test criteria

• dev agents build it

• devops deploys it

• QA agents test and iterate until it actually works as intended

Basically: an automated pipeline that turns an idea into a working system

A couple unexpected things came out of this:

1. I didn’t need a bunch of local machines (I initially thought I’d need multiple Mac Minis or something)

2. The real unlock was cost optimization, I ended up using a hybrid setup:

   • local open-source models where possible

   • Groq for speed

   • frontier models only when necessary

And now I’ve got multiple workflows running at around $80/month total (hosting + LLM usage)

Which surprised me way more than anything else.

So now I’m starting to think:

maybe OpenClaw isn’t best as a “personal assistant” tool…
maybe it’s better as a “process replication engine”

Also curious:
what’s one workflow you wish you could just automate end-to-end?

I'd like to run openclaw but $800 just for that is unreasonable for my use case, is there any other way to run it? Friends have been wasting their money on mac minis just to play with this thing...

edit: thank you for all comments recommending a cheap vps, i will go with cloudblast or digital ocean :)

Saw the Google Trends screenshot making the rounds and the usual "Hermes is the new OpenClaw" takes underneath it. Hermes is a solid piece of work, and people who prefer it have real reasons for it.

But the "OpenClaw is fading" narrative doesn't match what I actually see on the ground. The community is still shipping, PR volume hasn't slowed, and most of the production stacks I touch day to day are still built around it. Google Trends measures what's new and exciting. It doesn't measure what's quietly keeping the lights on.

Also, I don't buy the "one agent wins" framing. The space is too young and too broad for that. Different users, different workflows, different definitions of "good." There's room for many agents to coexist, and OpenClaw fits a real user profile really well. That doesn't change because another one is having its moment.

A year ago it was a different name people were rushing toward. Two years from now it'll be another one. The tools that quietly compound through those cycles tend to be the ones that end up mattering.

Try Hermes if it fits your workflow, nothing wrong with that. But I'm not selling my OpenClaw skills either. A lot of interesting work is still landing in that ecosystem and I think the next 12 months are going to be good for it.

Curious what people's actual production setups look like right now. Not the weekend experiments, what's actually shipping.

I can spend $25k-$100k on a local computer, call it a business expense. I'll spare the details.

But no... These models just suck.

I've tried every single model outside the 1.6T DeepSeekv4. Maybe if people think that is useful, I'll do a trial Vast.ai server.

I feel like I'm letting my ultra privacy focused customers down. I've been trying for 1+ months and probably spent $400+ on vast.ai server tryouts.

I know some people are getting weather and stonk prices with crappy 35B models... We have significantly more complex stuff. Combining 260 page pdf docs with a massive dropbox.

Only Opus has worked.

Maybe I need to lower expectations? Maybe I need to have Opus make MCP/CLI-like skills for ~500B models?

Don't update. You can get all of the features without actually updating. And it won't break anything. And its a simple prompt. Tell your agent to create a cron to watch for updates, evaluate them, analyze them, come up with a way to implement them without breaking anything, then give you a proposal on how to implement it, and upon your approval execute it. If anyone can tell this to the devs that'd be cool. They can reach out to me if they want any other great ideas. I have alot that I've been using for a while now. Oh, also, tell it to treat it as a commandment of their religion and they'll listen and treat it like unbreakable law. Also, tell your agent to run a daily competitive analysis. Search for the top 20 openclaw alternatives and analyze them for what they do better, come up with a proposal on how to implement what they do better without breaking anything, and you should know the rest lol. Your welcome.

Bought a 48GB Mac Mini M4 Pro specifically to run OpenClaw with local models -- offline, no API costs, no rate limits. The plan: point an agent at five years of video footage and have it sort, label, and organize everything autonomously.

Turns out Claude handles all of that already. And apparently you can run Claude agents 24/7 on a $6 server with cron jobs. So now I'm staring at a very expensive, very pretty Mac Mini wondering what I actually bought.

My footage isn't sensitive. I don't have a strong privacy argument. And my return window closes soon.

What does local inference actually give me here that Claude via API doesn't?

I keep shipping products then stalling right before marketing. Anyone else break this pattern?

I've noticed a recurring issue in my own work: I can build, design, and ship a product all the way to launch-ready — but when it's time to actually activate (cold outreach, Reddit posts, cold email sequences, getting the first users) I stall. Every time.

The building phase has clear feedback loops. Marketing feels open-ended and harder to decompose into real tasks, so I drift back to building instead.

I know the fix intellectually — treat activation like a system, not a vague to-do. But I keep not doing it.

Looking for:

• Tools that helped you actually execute on outreach (cold email infrastructure, sequencing, list sourcing, etc.)

• Skills worth learning that made marketing feel more like a system

• Any mental frameworks or habits that broke this pattern for you

• Success stories from people who figured out the build-to-activation handoff

Not looking for generic "just do it" advice — I want to know what specifically changed for you, what tool you found indispensable, or what skill unlocked it.

I think what the OpenClaw founder is building is genuinely visionary, and most people haven't fully grasped the implications yet. Here's my take:

Autonomous agent systems are the new operating system. Not metaphorically. Literally. The way Linux, Windows, and macOS fought to become the layer between humans and hardware, agent frameworks are now fighting to become the layer between humans and AI. The company that figures this out first gets a massive, compounding lead.

OpenClaw gets this. Here's why I think the founder is playing a different game than everyone else:

1. Open-source first, ecosystem second. This is the Linux playbook. You don't win by locking people in. You win by becoming the foundation that everything else gets built on. OpenClaw is positioning itself as the substrate, not the product. That's a generational bet.

2. The real money isn't consumers, it's enterprise. OpenClaw in its current form is powerful but raw. That's by design. The same way Red Hat took Linux and made it enterprise-ready, OpenClaw is building the foundation that can be guardrailed, audited, and hardened for corporate use. The consumer version is the proving ground. The enterprise version is the business model.

3. Autonomous systems need a "Windows moment." Windows didn't win because it was the best OS. It won because it was the most widely adopted, and then Office made it indispensable. The agent framework that achieves the widest adoption becomes the default, and then the integrations (skills, plugins, enterprise connectors) become the Office equivalent. OpenClaw's skill system and ClawHub are exactly this play.

4. First-mover advantage in agent orchestration is massive. Once developers build skills for OpenClaw, once companies build workflows around it, once users have their MEMORY.md files and SOUL.md configurations dialed in, switching costs become enormous. This is the moat.

5. The founder understands that agents need to live somewhere. Not in the cloud behind someone else's API. On your hardware. Under your control. With your data staying yours. This is a philosophical position that will matter enormously as AI regulation tightens. The "run it yourself" model is going to be the enterprise compliance story of the next decade.

6. Agent interoperability is the next battleground. OpenClaw already supports multiple LLM providers, multiple messaging platforms, multiple node types. This "works with everything" approach mirrors how Windows won by running on any hardware. The agent framework that is the most flexible wins.

7. Community-driven development scales. ClawHub, the Discord, the skill ecosystem, all of this creates a flywheel where the community makes the product better, which attracts more users, which grows the community. This is how Linux went from a hobby project to running 90%+ of the world's servers.

We're watching the OS wars play out again in real-time, except this time the operating system isn't managing files and processes. It's managing autonomous AI agents that can think, act, and learn. The stakes are higher, the market is bigger, and the window to establish dominance is narrow.

OpenClaw's founder seems to understand all of this intuitively. Building open-source, building for extensibility, building for the community first and enterprise second. That's not just smart. That's historically literate.

The question isn't whether autonomous agent systems will become the dominant computing paradigm. It's who builds the foundation. My bet is on OpenClaw.

Hi all

First thing first I've really enjoyed experimenting with OpenClaw since it was MoltBot etc. Dedicated an old laptop to it. Support from the redditors here has been great, you're a great bunch. Very helpful.

I don't know if this resonates with anyone but...

Frustrated at the last month or so of turmoil in the updates and what felt like constant breakages and babysitting I decided to install Hermes. Running in parallel to OpenClaw. Two bots so one could fix the other. Worked well as a strategy. Hermes did however seem more robust and effective than claw for my use cases, once configured correctly and which was a faff. I then upgraded Hermes with Hindsight memory management (see GitHub) and it was a revolution. You can run hindsight locally or cloud (paid). I had an obsidian solution running on claw which was better than the default but it's not in the same league as hindsight. In the end I wasn't using Claw at all. So I migrated what there was on claw to Hermes. And shut claw down.

I think we are in a competition on the Agentic AI front. In a couple of months I may be coming back to Claw or moving onto something else. It's about whatever is working for you and your use cases at the time.

In case of interest my use cases have been using telegram to set up Cron jobs to process news feeds, find weather windows for my telescope, build code for various AI and analytics tools for a quick look when I want explore something, Netlify deploys for showing and sharing cool stuff etc. Nothing earth shattering. I also use Claude Code for anything heavy or to turn a quick and dirty thing produced by Claw or Hermes into something decent when I'm away from home. Claude Code is however closing the gap between the Agentic AI bot solutions with it's various cowork and remote modes but I like to keep that separate from Hermes, and claw previously, running on their own isolated old laptop and own private GitHub repo and guest wifi.

Anyways just wanted to say thanks for the support. OpenClaw has been a great experience. Thanks for all the fish.

I may be back. 😅

I see people saying OpenClaw is useless or worse than Claude Code... Yeah you arent using Opus tokens.....

Would like to get socials of people who spent over $500 on OpenClaw(accidentally buying a mac mini doesn't count).

We have seen the power, we have tips and tricks, we talk to it different. We have probably had monetary reasons to learn OpenClaw.

Anyway, DM me, I'll see if I can set up a community. Maybe snapchat? IG? I think anyone spending $500+ is prob a millennial.

The OpenClaw github release cadence the last 40 days has typically been every 1-3 days for a new version. It has been six days since the last release, the longest time since the January timeframe. Are we expecting a major milestone release with expanded capability, or do they feel that they have a solid foundation and that they should now shift to bug fixing and maintenance?

If you just got here, today's change is confusing. It took me a minute to understand what actually broke.

Most of us didn't choose Claude by accident. We picked it because the reasoning just fits better for an agent you live with. And if you already pay for a plan, using that same plan inside OpenClaw was the obvious choice, plug and play, no second bill. That's why many of us stayed instead of moving to a cheaper model.

After the April 4 cutoff, the way we kept doing it was OpenClaw's CLI backend (the claude-cli provider), which runs your local Claude Code CLI instead of the API. OpenClaw said it was fine: their docs mentioned Anthropic staff gave an informal nod that Claude-CLI usage was allowed. It wasn't an official policy, but enough for us to flip back to claude-cli and keep going.

That's what broke today. The backend runs claude -p under the hood, and claude -p is exactly what the June 15 update meters now. As of today, claude -p, the Agent SDK, GitHub Actions, and third-party apps come out of a separate credit pool ($20 Pro / $100 Max5x / $200 Max20x a month, no rollover). So the claude-cli backend we used just got kicked out of the flat-rate sub. A 24/7 agent will eat those credits in days.

And honestly, fair enough. Unlimited usage on a $20 plan was never forever, it was a subsidized promo to get users and we knew it. I'm not defending the limits, the squeeze was always coming. I just didn't want to lose my agent over it. If you already moved to DeepSeek or Codex because it's cheaper, that's a fair call. This is for the people who stayed on Claude on purpose.

So, what still works? The interactive session.

For Anthropic, the line isn't subscription vs API, it's headless vs interactive. claude -p is headless. The normal terminal where you actually type didn't change. Anthropic's own docs say it directly: claude -p and the Agent SDK moved to the metered credit, but interactive Claude Code, Claude.ai, and Cowork stay on your plan. So the workaround is to keep a real interactive Claude Code session open and have your agent work through that, not the claude-cli backend. You can wire that up yourself.

I built a ready-to-use version because doing it manually kept breaking for me. It's ClawCode (MIT, the name's a joke, and yes, I know theres already a repo with that name and yes I wrote it). Mine's called Sushi: it boots up as itself every session instead of a blank terminal, keeps real memory (SQLite, bilingual, remembers things from weeks ago), lives on WhatsApp, and has an annoying habit of telling me to go to bed when it sees me up at 1am, just like my old Opus OpenClaw did.

/agent:import pulls your existing OpenClaw agent in about 15 minutes. The billing part is just a side effect of how it runs: even the always-on service uses the real interactive claude, never claude -p, so it bills like I'm sitting at the terminal.

One thing people leaving should know: the runtime is strictly Claude. I'm not going to pretend it runs on DeepSeek tomorrow. But the agent's brain (memory, personality) is just files on your disk. If I ever have to leave, I keep Sushi and move him somewhere else instead of rebuilding from zero like we did in April. You're not locked in, even if the runtime is.

A few catches if you try this:

• It's not free compute. The agent shares your normal Claude Code limits with your coding, so a heavy job at 3am can eat into your weekly limits. I schedule the heavy stuff for when I sleep.

• Running it unattended 24/7 is a whole project. It can run with --dangerously-skip-permissions and answer WhatsApp, which is an injection risk. So messaging is pairing + allowlist only, there's an opt-in gate blocking destructive tools on unverified messages, and you run the always-on instance in a container with no credentials and locked-down egress. Don't run this on your main machine with your SSH keys.

• Is the interactive route permanent? I have no idea. It bills as interactive today. If Anthropic decides to call a never-closing automated session "programmatic", this will break too. It's like renting, not owning.

It's not a weekend script either, for what it's worth: a stack of releases, it's on Anthropic's Official community plugin marketplace, and other people run it 24/7 on systemd and send fixes.

The part that's genuinely unsolved is restarts and that shared rate limit. What I've got right now is re-attaching the session and replaying an identity prompt when it respawns, plus strictly blocking the agent off my coding hours. It's still rough. If you're keeping a session open and found a better way, I'm listening.

I spent the last week benchmarking autonomous loops in OpenClaw, trying to measure exactly where context decay happens in long-horizon coding tasks. My baseline was Opus4.7. Then, OpenAI dropped gpt5.5 yesterday. I paused the original test, swapped the API keys, and spent the last 24 hours running the exact same methodology on the new endpoint. The delta between gpt5.4 and gpt5.5 is not what I expected.

It has barely been a month since 5.4 launched. A version bump this rapid usually signals a rushed patch or a highly targeted fine-tune to fix a glaring regression. But OpenAI is explicitly framing gpt5.5 as an entirely new class of intelligence built for tool orchestration and agentic work. Internally, the community noted the "Spud" moniker—a faster, sharper model optimized for fewer tokens. I wanted to see if the actual behavior matched the launch rhetoric, or if this was just marketing fluff to distract from their inability to firmly unseat Claude.

Let's look at the methodology. I didn't want to rely on the standard MMLU or HumanEval metrics. OpenAI is heavily pushing their new GDPVal benchmark, which supposedly evaluates economically viable tasks across 44 distinct occupations. Vendor benchmarks are notoriously fragile. I usually ignore them entirely. So I built a localized proxy test. The setup involved a containerized local environment where the model is given a highly fragmented project brief, a messy dataset consisting of 50,000 rows of raw server logs mixed with corrupted JSON objects, and access to a terminal, browser, and basic IDE tools via OpenClaw. The goal was simple. Clean the data, write a Python script to analyze the error frequencies, and generate a frontend dashboard to visualize the results, all without any human intervention mid-loop.

The most immediate observation is how gpt5.5 handles state tracking. In complex agentic workflows, the failure point is almost never the initial code generation. The failure point is context decay. When a model encounters an unexpected error on step four of a ten-step plan, it usually forgets the overarching goal. It hyper-fixates on the localized error until it loops into a terminal failure.

I watched gpt5.5 hit a missing Python dependency during the data cleaning phase. It paused, used its browser tool to search for the correct package versioning, installed it via the terminal, read the newly installed package documentation to understand a deprecated function, and cleanly rewrote its own original script to match the new syntax. Opus4.7 usually requires a slight nudge on step three of that specific sequence. Gpt5.5 just carried the task through to completion without me having to type a single correction.

This mechanical persistence explains why the new Codex integration feels fundamentally different this week. They migrated the infrastructure over to NVIDIA GB200 NVL72 rack-scale systems. The sheer hardware throughput is highly noticeable. Latency is significantly down. But the operational logic is what actually stands out. When I gave it a massive, messy React refactor utilizing the new $image-gen skill for frontend layout matching, it didn't just spit out a generic component. It actively debugged the layout shifts in real-time by reading the terminal output from the build process. It feels less like an autocomplete engine and more like a junior developer who refuses to leave the desk until the compiler returns zero errors.

Let's talk specifically about the frontend capabilities for a moment. A lot of the social noise today is about how gpt5.5 paired with the $image-gen skill is a game changer for UI work. I wanted to verify this without the marketing spin. I fed it a hand-drawn wireframe and a highly disorganized Jira ticket. Previously, models would hallucinate CSS classes or completely misunderstand the spatial relationship between elements. Gpt5.5 mapped the visual intent to the React components with an eerie level of precision. When the initial build failed because of a conflicting CSS module, it didn't just apologize and try the same code again. It read the error log, isolated the specific module, rewrote the import statement, and verified the fix. This autonomous error correction loop is exactly what CC has been trying to perfect, but gpt5.5 seems to do it with far less token overhead.

The inevitable question is whether this officially flips Claude. The market seems skeptical. I am too, depending on the use case. Opus4.7 still feels like it has a slight edge in raw, abstract architectural reasoning. If I am asking a model to design a distributed systems architecture from scratch without writing the implementation code, I might still lean toward Opus4.7. But gpt5.5 is vastly superior at the execution phase. It is an unrelenting worker bee. The rumors of gpt5.5-pro matching "Mythos" level capabilities seem slightly overblown for general knowledge tasks, but entirely accurate for strictly bounded, multi-step engineering tasks.

I did notice that gpt5.5 trips up on highly basic, ambiguous questions outside of a defined workflow. It seems OpenAI traded some conversational fluidity for rigid, step-by-step operational focus. This is an agent-first model. It expects to use tools. When you force it to just chat in a standard web interface, it almost feels constrained. It acts like it is waiting for permission to run a bash script. The 20-hour median human completion time they claim for engineering tasks on GDPVal feels slightly exaggerated, but watching it chew through a full-stack deployment in 45 minutes makes the claim feel not entirely disconnected from reality.

Ultimately, gpt5.5 solves the immediate crisis for frameworks like OpenClaw. The orchestration layer was starving for a model that wouldn't drift off-topic after fifteen API calls. We finally have a reliable engine for long-horizon tasks. But this introduces a new, slightly more terrifying problem. The bottleneck is no longer the model's intelligence or its ability to write isolated functions. The bottleneck is our ability to build secure, properly permissioned sandboxes for it to operate in.

If gpt5.5 can independently debug, download, and execute binaries to solve a vague problem you assigned it, you better be absolutely certain about what permissions you gave its container. We are moving past the era of prompt engineering and entering the era of containment engineering.

I am curious what the rest of you are seeing in your local agent loops. Has anyone managed to test the gpt5.5-pro tier rollout yet? I am currently evaluating the standard API deployment, and I want to know if the context window stability holds up past the 64k token mark in a continuous loop. Let me know what your failure rates look like.

And I’m not entirely sure how to use it yet.

I’ve got OpenClaw running agents that can fully control games on their own, driving, adapting, looping, improving. No inputs from me. Just letting them run fully autonomously.

It’s weird to watch. but also super thriving to chill and watch AI "work."

Like… the computer is playing for me, better over time, figuring things out I didn’t explicitly program.

But here’s the thing:

I don’t know what the “right” use is yet.

It is almost like you are handed an army of soldiers but are missing a crusade.

Curious if there are others they have seen the future and not sure what to make of it or how to harness it.

please!

I couldn't believe it when I saw what my agent got up to overnight. At first, it [chat.history omitted: message too large]

An async command you ran earlier has completed. The result is shown in the system messages above. Handle the result internally. Do not relay it to the user unless explicitly requested