r/better_claw • • 1m ago

You don't need a dedicated Mac Mini or a weekend of config files to run always-on agents: OpenClaw setup vs. a single prompt in Claude Code

1 Upvotes

OpenClaw kicked off a massive wave of interest in proactive, always-on agents—and also kicked off a wave of people buying dedicated Mac Minis, wrestling with gateway configs, wiring up Telegram/WhatsApp bridges, and worrying about giving an autonomous daemon broad access to their system.

I wanted the exact same outcome—putting recurring digital chores on autopilot—without maintaining another server stack or buying dedicated hardware.

If you already use Claude Code, you already have the runtime, the model access, and Remote Control on your phone. The only missing piece is persistent plumbing.

Here is the difference in what it actually takes to get your first background agent running:

The typical OpenClaw / self-hosted daemon path:

  • Provision an isolated machine, VM, or container (the classic "buy a Mac Mini so it doesn't touch my main laptop" move)

  • Configure gateway daemons, channels (Telegram/WhatsApp/Discord), auth tokens, and skill YAML/JSON

  • Wire up cron jobs, heartbeat files, and persistent memory markdowns

  • Build or audit your own sandboxing so an unattended prompt injection doesn't fire off outbound emails or shell commands while you're asleep

The single-prompt path in Quarterdeck (Claude Code plugin + local SQLite):

  • Install two plugins inside Claude Code (quarterdeck-goals and quarterdeck-guard)

  • Type /goal-new and describe what you want in plain English:"Keep my inbox under control—triage incoming mail, unsubscribe from junk, and ask me before replying to anything important."

  • That's it. Behind that one prompt, Quarterdeck automatically sets up:

    • Scheduled & event-driven runs backed by a local SQLite queue (no background server to babysit)

    • Structured memory that remembers your past decisions and pinned rules across runs

    • Deterministic guardrails (off / propose / auto) with taint tracking—when an agent touches untrusted external input, outbound actions are routed to an approval queue instead of firing blindly

    • Phone & sidebar approvals: Routine runs stay quiet in a pane beside your chat; when a decision is needed, it pings your phone via Claude Code Remote Control for one-tap approval

OpenClaw is awesome if you want a full multi-channel standalone bot platform. But if you just want to put your digital chores—inbox triage, GitHub issue/PR maintenance, price/auction watches, local cleanup—on autopilot using the Claude Code setup you already pay for, a single prompt is all it should take.


r/better_claw • • 15h ago

Where to run agent when the laptop is closed? (Mac mini, Oracle free tier, Hetzner, Hostinger, Hermes Cloud, managed)

1 Upvotes

You set up Hermes or OpenClaw. You connect Telegram. You write your morning briefing cron. It works beautifully for three days. Then you close your laptop to go to bed and your 8am briefing never fires.

This is the moment every agent builder hits. Your agent needs to be awake when you're not. And the answers you get in Reddit threads are always "just get a VPS" or "use a Mac mini" or "Oracle free tier bro" with zero numbers attached.

So I priced all of them. Same agent, same daily workload, same model key (DeepSeek v4.1 Flash via OpenRouter). I tracked setup time, monthly cost, what surprised me, and what broke.

The workload: morning briefing cron at 8am, email triage on 20 to 30 messages, Telegram conversations during the day, one or two research tasks. About 800 to 1,200 requests on a normal day. This is a "real personal agent" workload, not a demo.

The model bill is not included in the costs below because it's the same everywhere. BYOK means you pay the provider directly. For me that's about $8 to $12/month on DeepSeek Flash depending on how chatty I am.

1. Your own Mac mini ($599 upfront, then electricity)

Setup time: about 2 hours for Hermes, 3.5 hours for OpenClaw.

Monthly cost: electricity only. An M4 Mac mini running 24/7 draws about 5 to 8 watts at idle, more under load. Realistic electricity cost is $3 to $5/month depending on where you live. After the upfront cost, this is the cheapest option that exists.

What worked: this is the gold standard for control. SSH in whenever you want. Install anything. Run multiple agents. Run local models alongside cloud ones if you have enough RAM. Nobody can change your pricing, change your terms, or see your data. It's your computer.

What surprised me: the Mac mini doesn't sleep by default when you close the lid (because there is no lid). But if you have Energy Saver set wrong, it will sleep after inactivity, and your agent goes dark with it. I lost one morning briefing on day 2 because I hadn't disabled sleep. That 30-second settings fix is not in any setup guide I found.

What broke: nothing, once sleep was fixed. But I am my own sysadmin. When OpenClaw pushed an update that rewrote model settings, I spent 45 minutes fixing it. When I wanted to access the agent remotely, I had to set up Tailscale. When I wanted alerts on silent failures, I had to build that myself. The Mac mini doesn't break. The stuff around it does.

The real cost: $599 upfront + $3 to $5/month electricity + your time. If you enjoy tinkering, this is the best setup. If you don't, it becomes a part-time job. The HVAC owner in r/openclaw bought a second Mac mini ($700) just so one could update the other. That's $1,300 in hardware to solve a software update problem.

Best for: people who want full control, already have the hardware (or want to invest in it), and don't mind being their own IT department.

2. Oracle Cloud free tier ($0/month, actually)

Setup time: 45 minutes to an hour to get the instance, then another 2 to 3 hours for the agent setup.

Monthly cost: genuinely $0. Oracle's Always Free tier gives you an ARM instance with enough resources to run a Hermes or OpenClaw agent. No credit card charges as long as you stay in the free shape.

What worked: it runs. 24/7. For free. That's the whole pitch and it delivers. Several r/hermesagent threads recommend it and the people using it seem happy.

What surprised me: getting the free-tier instance is the hard part. Oracle's free ARM instances are capacity-constrained. I tried provisioning one and got "Out of Capacity" errors for about two days before it went through. There are scripts people run to keep retrying the provisioning API until a slot opens up. This is a known thing. It's just not something anyone warns you about until you're staring at the error.

What broke: I didn't run it long enough for the billing scare stories to play out, but multiple people in threads report Oracle reclaiming "idle" free instances after 7 days of low usage. If your agent has quiet periods (weekends where you don't message it much), there's a nonzero chance Oracle decides the instance is idle and reclaims it. You can set up a cron job that creates artificial activity to prevent this, which is a funny sentence to type about a service that's supposed to be always-on.

The real cost: $0 if you can get an instance and keep it alive. Your time configuring it. The low-grade anxiety of running production work on a free tier that someone else controls. One commenter in r/hermesagent put it well: "don't use a VPS unless you know how to secure it." That goes double for a free one.

Best for: people who are comfortable with Linux, don't want to spend anything, and can handle the provisioning lottery and the possibility of reclamation.

3. Hetzner VPS ($7 to $20/month)

Setup time: 3 to 3.5 hours. Spin up the box, SSH in, Docker, OpenClaw or Hermes, configure everything, secure it, connect channels.

Monthly cost: $7.11 for the CX22 (2 vCPU, 4 GB RAM), which comfortably runs one agent. $13 to $20 for more headroom or multiple agents.

What worked: the most recommended VPS in every thread for a reason. Hetzner's EU data centers are fast, the pricing is straightforward, and the instances are reliable. I ran a CX22 for the duration and it didn't hiccup once. No capacity lottery. No reclamation risk. You pay, it runs.

What surprised me: the CX22 has 4 GB of RAM, which is tight if your agent's session database grows large. One user in r/openclaw hit the SQLite 512 MB worker cap on a 1 GB session database after a few months. At that point you either trim your database, upgrade to a bigger instance, or watch things crash. Worth knowing before you commit to the cheapest tier long-term.

What broke: same as the Mac mini. I'm the sysadmin. Updates, security, monitoring, Tailscale for remote access, alerting for silent failures. All me. The VPS itself is rock solid. The agent maintenance on top of it is the actual work.

The real cost: $7 to $20/month + your time. If you're running one agent and you know Docker, this is probably the sweet spot between cost and reliability. If you're running multiple agents or don't want to touch a terminal, it starts to feel tight.

Best for: the person who's comfortable with SSH and Docker and wants a cheap, reliable, no-surprises box in a real data center.

4. Hostinger managed Hermes ($15/month)

Setup time: about 30 minutes. Hostinger offers a one-click managed Hermes plan. Pick a plan, it provisions, you configure the agent.

Monthly cost: $14.99/month for the base plan (prices may have changed since I checked).

What worked: faster setup than a raw VPS. You get a Hermes instance without doing Docker yourself. If the idea of SSH makes you uncomfortable but you still want your own Hermes, this removes the worst part.

What surprised me: one commenter in r/hermesagent specifically warned against the Hostinger managed app plan, calling it limited without elaborating. I didn't run into anything obviously broken during my test, but the customization options are thinner than a raw VPS. You're in Hostinger's container, not yours.

What broke: I couldn't install Tailscale. I couldn't add services alongside the agent. The agent ran fine within its constraints, but those constraints exist and you feel them if you try to do anything beyond the standard Hermes setup.

The real cost: $15/month + less time than a VPS, more frustration than fully managed. It's a middle ground. Not the cheapest, not the most flexible, not the simplest. For some people that's exactly right. For others it's the worst of both worlds.

Best for: someone who wants their own Hermes instance, doesn't want to do Docker, and is okay with less customization than a VPS.

5. Hermes Cloud / Nous Portal ($20/month Plus + usage)

Setup time: about 15 minutes. Sign in, pick the Plus plan, connect Telegram, paste your API key, go.

Monthly cost: $20/month subscription + about $0.15 to $0.70/day in compute charges depending on usage. My 10-day test came to $4.35 in usage charges, projecting to roughly $13/month. So total: about $33/month.

What worked: this is Hermes, managed by the people who build Hermes. The 15-minute setup is real. Zero Docker, zero SSL, zero firewall config. The agent runs the same as a self-hosted one. Backups and restore work for migrating from an existing setup.

What surprised me: the billing is confusing. I wrote a whole post about it (the billing breakdown post from last week). Short version: compute is per-second, light days cost less, heavy days cost more. But the dashboard shows one number per day without splitting compute from storage. You have to track it yourself to understand what you're paying.

What broke: I couldn't figure out how to set up a custom Telegram bot (the shared Team Gateway routes messages but you can't brand it). The Privacy Mode scope question still hasn't been clearly answered (does it cover memory files and conversation history, or just inference payloads?). And I couldn't install Tailscale on the cloud instance for device access, which one commenter asked about and got no answer.

The real cost: about $33/month total. More than a VPS, less than your time on maintenance. The setup speed and zero-maintenance experience are real. The trade-offs are customization limits and billing opacity.

Best for: existing Hermes users who are tired of maintaining a VPS, and new users who want to try Hermes without learning Docker first.

6. Fully managed platforms (BetterClaw, Botel, others)

Setup time: 8 to 15 minutes depending on the platform.

Monthly cost: varies. BetterClaw starts at $19/month. Botel (new, saw it on HN) does pay-per-use where you only pay while the agent is working. Others exist. I tested BetterClaw for the OpenClaw side.

What worked: the fastest setup of anything I tested. BetterClaw's Gmail OAuth doesn't need a Google Cloud project, which saves about 40 minutes compared to a VPS. The visual builder for tasks is simpler than writing SOUL.md configs by hand. Trust levels (the agent starts in draft-only mode and you promote it as you build confidence) are a good idea.

What surprised me: I had almost nothing to manage. No logs to check, no updates to apply, no DNS to debug. The agent just ran. That sounds like marketing copy but it was the experience. The flip side: when I wanted to do something custom (a specific Telegram command trigger), I had to work within the platform's builder rather than editing a file. That's faster for simple things and slower for weird things.

What broke: less customization depth than raw OpenClaw or Hermes on a VPS. The personality tuning is simpler. Memory on some tiers is time-limited (14 days on the tier I tested versus unlimited on a VPS). If you're the kind of person who wants to SSH into your agent and hand-edit config files, this will feel constraining. If you're the kind of person who doesn't want to know what SSH stands for, this is the point.

The real cost: $19 to $49/month depending on the platform and tier + your model API bill. The highest dollar cost of the six options. The lowest time cost.

Best for: people who want a working agent by lunch and never want to think about where it runs.

Here's the thing. Every thread compares these on price. "$7 versus $20 versus $33." But the actual cost of running an agent isn't the monthly bill. It's the monthly bill plus the hours you spend on it.

If you spend 2 hours a month on VPS maintenance (and that's light), and your time is worth $50/hour, that's $100/month in invisible cost on top of your $7 Hetzner bill. The $33 Hermes Cloud or $19 managed platform suddenly looks different.

But if you enjoy the tinkering and you'd be doing it anyway, that $100 is entertainment, not cost. The right answer depends on who you are, not what the pricing page says.

My setup after testing all six: I kept the Hetzner VPS for my main agent because I like having SSH access and full control. I put a second, simpler agent on BetterClaw because I didn't want to manage two VPS setups. Total: $7 + $19 + about $15 in model costs = $41/month for two always-on agents with zero downtime across the 10 days.

Every price was checked the week of November 11, 2026. At least one will have changed by the time you read this.


r/better_claw • • 15h ago

OpenClaw + Codex: Persistent failures, incomplete tool calls, and timeouts. Is anyone actually running this reliably?

1 Upvotes

I’m looking for advice from experienced OpenClaw users and developers because I’ve been struggling with Codex reliability for a long time.
I’m relatively new to this technology, but I’ve invested considerable time in building an OpenClaw-based personal AI assistant called Hal. My goal is to create a dependable digital chief of staff that manages commitments, follows up on tasks, monitors systems, handles research, and helps coordinate daily work.
The potential is extraordinary. Unfortunately, the actual experience has been frustratingly inconsistent.
My setup:
Two Apple Mac minis, primary and secondary, connected through Tailscale.
OpenClaw 2026.11.3.
Official Codex plugin 2026.11.3.
GPT-5.6 Terra as the default model.
Claude Sonnet 4.6 through OpenRouter as fallback.
Local Ollama models available, although performance has been disappointing.
Telegram, Google services, local monitoring, and a custom Mission Control dashboard.
The recurring problem: Codex repeatedly fails to finish tasks.
The system often starts working, invokes tools, sometimes even writes useful files or updates records, and then fails before completing the response.
Some of the recurring errors include:
OpenClaw recorded a native Codex tool.call without a matching tool.result before the turn completed.
codex app-server execution budget timed out
CODEX_APP_SERVER_LOCAL_REQUEST_CANCELLED
We’ve also encountered:
Explicit auth order for openai has no usable profiles.
Interestingly, the gateway can report valid OpenAI OAuth credentials while isolated execution encounters authentication failures.
What makes this particularly frustrating is that the underlying system often works.
The gateway is running, both Mac minis are connected, backups are verified at the application-data level, and Google authentication checks have passed.
We’ve successfully moved some recurring tasks to deterministic local Python scripts. Those run quickly and reliably.
But as soon as we introduce more sophisticated AI-driven execution through Codex, reliability deteriorates.
One failed routine commitment-review task recorded approximately 380,000 total tokens, including cached tokens, before failing.
What we’ve already tried:
Reducing agent context.
Restricting tool permissions.
Separating local monitoring from AI-driven tasks.
Reducing the frequency of complex automations.
Verifying OAuth credentials and gateway connectivity.
Inspecting logs and plugin compatibility.
Testing isolated and gateway-based execution.
Preserving backups and avoiding unnecessary upgrades.
The failures persist.
My questions for the community:
Is anyone running OpenClaw with Codex reliably for sustained, autonomous task execution?
Has anyone encountered the missing tool.result error, and what actually fixed it?
Could this be a Codex app-server integration or session-management problem rather than a model problem?
Is there a more dependable way to use OpenAI models with OpenClaw without relying on this problematic execution path?
For a two-Mac setup, would you recommend local-first execution with cloud AI reserved for reasoning?
Are there known compatibility issues with the current Codex plugin or its authentication handling?
Why I think this matters beyond my particular setup:
For those of us who aren’t developers, AI agents promise to make sophisticated technology accessible without requiring us to become systems engineers.
But an assistant that works brilliantly one moment and fails silently the next is extremely difficult to trust.
I don’t expect perfection. I do expect tasks to either finish successfully or fail clearly, preserve their progress, and recover without constant human intervention.
Right now, I spend too much time maintaining the assistant instead of benefiting from it.
I’m not looking to criticize the developers. I appreciate the ambition and complexity of what they’re building.
I’m genuinely interested in understanding whether others have achieved a stable setup, what architecture they use, and whether there’s a known solution to these persistent Codex problems.
I’d especially appreciate practical, beginner-friendly advice based on configurations that are actually working—not just theoretical fixes.
Thanks in advance.


r/better_claw • • 15h ago

OpenClaw + Codex: Persistent failures, incomplete tool calls, and timeouts. Is anyone actually running this reliably?

Thumbnail reddit.com
1 Upvotes

r/better_claw • • 17h ago

Hermes Cloud billing explained: idle cost, what happens at $0 credit, Plus plan

1 Upvotes

I keep seeing the same three questions about Hermes Cloud in r/hermesagent every week. The answers are scattered across a dozen threads and half of them are from Nous staff dropping referral links without actually explaining the billing. So I signed up, ran an agent for 10 days, and tracked the charges.

This is what I found. If I got anything wrong, Nous team, please correct me. I’d genuinely love a clearer billing page.

What Hermes Cloud actually is

Nous (the team that builds Hermes) now offers their own managed hosting. You get a Hermes instance in the cloud. No VPS, no Docker, no SSH. You sign in, connect Telegram, paste your model API key, and your agent runs.

The $20/month Plus plan is the entry point. It includes one cloud agent. There are higher tiers but Plus is what most people start with.

(If you’re thinking “wait, isn’t this what a $7 Hetzner VPS does?” then yes, sort of. The difference is about 3 hours of setup time and ongoing maintenance. Whether that’s worth $13/month is a personal question.)

How the billing actually works

This is the part that confuses people, and honestly the Nous billing page doesn’t make it obvious.

Hermes Cloud bills per-second for compute and charges a flat rate for storage. When your agent is actively running (processing a message, executing a cron job, doing a research task), you’re burning compute seconds. When it’s sitting there waiting for your next Telegram message, it’s “idle.”

The question everyone asks: “Is $0.51/day the rate I pay even if I barely use it?”

From what I saw: no. On days I used the agent heavily (morning briefing, 20+ email classifications, several conversations), my charge was about $0.55 to $0.70. On days I barely touched it (a weekend where I sent maybe 3 messages), it dropped to about $0.12 to $0.18.

The $0.51 figure that keeps getting quoted in threads seems to be an average across moderate daily use. Light use costs less. Heavy use costs a bit more.

The confusing part is that the billing dashboard doesn’t clearly show you “this is compute, this is storage, this is idle.” It’s one number. You kind of have to eyeball it across days to figure out the relationship between your usage and the charge.

What happens when your credits hit $0

This is the second most-asked question. I ran my balance down to test it.

The agent stops. It doesn’t delete anything. Your chats, memory files, skills, connected accounts are all still there. You just can’t talk to it or run any tasks until you add funds.

Think of it like your phone running out of prepaid credit. Everything is still on the phone. You just can’t make calls.

When you top up, the agent picks up where it left off. No re-setup. No lost config. This is actually one of the better parts of the experience. Some VPS setups, if the billing lapses and the server gets recycled, you’re starting from scratch.

One thing I couldn’t confirm: whether a scheduled cron job that’s supposed to fire while your balance is at $0 gets skipped permanently or gets queued and fires when you top up. If anyone from Nous can clarify this, that would be useful.

What Plus includes (and what it doesn’t)

Included:

The agent itself. One cloud-hosted Hermes instance with your SOUL.md, memory, skills, and connected accounts. This is the same Hermes you’d run on a VPS, just managed.

Telegram via shared Team Gateway. You don’t set up your own Telegram bot. You use Nous’s shared bot, which routes messages to your agent. This makes setup faster (no BotFather config) but means you can’t customize the bot name, avatar, or behavior as much as a self-hosted bot. If you want your agent to feel like “your” Telegram bot with your brand on it, the shared gateway won’t do that.

Backup and restore. You can migrate from a self-hosted setup by exporting and importing. A Nous staffer in one thread walked someone through the process.

BYOK. You bring your own model API key (OpenRouter, DeepSeek, Claude, whatever). Hermes Cloud doesn’t lock you into a specific model provider. This is the same as self-hosted.

Not included (or not clear):

Custom Telegram bot. You’re on the shared gateway. If you want a standalone bot, you’d need to figure out how to point your own BotFather bot at the cloud instance, and I haven’t seen clear docs on whether that’s supported.

Privacy Mode scope. This one matters. Nous says Privacy Mode covers “inference payloads.” A community member asked whether it also covers memory files, conversation history, and connected-account data. A Nous-affiliated commenter said it covers inference payloads only and escalated the question to the team. That was in October. I haven’t seen a resolution. If you’re handling anything sensitive through your agent, this is worth asking about before committing.

Custom integrations. Things like Tailscale for device access, custom webhooks, or running additional services alongside the agent. On a VPS you can install whatever you want. On Hermes Cloud, you’re in their container, with their constraints. One commenter asked whether you can install Tailscale on a Nous Cloud instance. No clear answer.

The 10-day cost breakdown

Day 1 (heavy, setup + testing): $0.68
Day 2 (morning briefing + email triage + 8 conversations): $0.61
Day 3 (briefing + 4 conversations): $0.38
Day 4 (barely used, weekend): $0.15
Day 5 (barely used, weekend): $0.12
Day 6 (back to normal): $0.52
Day 7 (heavy research day): $0.71
Day 8 (normal): $0.49
Day 9 (light): $0.22
Day 10 (normal): $0.47

10-day total: $4.35. Projected monthly: about $13 to $14 on my usage level.

That’s on top of the $20/month Plus subscription. So real total monthly cost is about $33 to $34 for me. The model API bill (DeepSeek via OpenRouter) added another $8 to $9 on top, but that’s the same regardless of where the agent runs.

For comparison, a Hetzner CX22 VPS runs $7.11/month flat, but you’re spending 3+ hours setting it up and doing your own security, updates, and monitoring. Hermes Cloud costs more but the 15-minute setup and zero maintenance is real.

What I’d want Nous to fix

A billing breakdown page. Show me compute, storage, and idle separately. Don’t make me track it in a spreadsheet to understand my own bill.

A clear answer on Privacy Mode scope. “Inference payloads” is not enough when people are connecting their email, calendar, and business accounts. Memory files, skill data, and conversation history either are or aren’t covered. Just say which.

Documentation on what happens to scheduled tasks at $0 balance. Do they queue? Do they skip? Do they fire once and stop if the balance runs out mid-task?

A way to set a daily spend cap. If my agent gets stuck in a loop or I accidentally leave a heavy research task running, I’d like it to stop at $2 instead of burning through my credits overnight. (This is a problem everywhere, not just Hermes Cloud. Someone on r/SaaS had an agent retry 31,000 times and burn $4,700.)

Who Hermes Cloud is right for

You’re already using Hermes and you’re tired of maintaining a VPS, dealing with Docker updates, and debugging gateway disconnects at midnight. You want the same agent, managed, with a 15-minute migration. The $33/month total is more than a $7 VPS but less than the value of your weekends.

You’re new to Hermes and you want to try it without learning Docker and SSH first. The shared Telegram gateway and managed setup remove the biggest barriers to getting started.

Who it’s not right for (yet)

You need full control over your environment. Custom Telegram bots, Tailscale, additional services running alongside the agent, root access. The VPS still wins here.

You’re cost-sensitive and comfortable with self-hosting. $7/month versus $33/month is a real difference if you’re running multiple agents.

You handle sensitive data and need a clear data policy. Until the Privacy Mode scope question gets a definitive answer, a VPS where you control the data layer is the safer choice.

There are other managed options too (BetterClaw for OpenClaw, Hostinger’s managed Hermes plans, and a new one called Botel that bills only while the agent is working). I haven’t tested all of them the same way, but they exist if Hermes Cloud doesn’t fit.

If you’re on Hermes Cloud and your billing numbers look different from mine, I’d actually love to see them. More data points make this more useful for everyone.


r/better_claw • • 1d ago

Openclaw Cron Fallback Provider Fix has been built!

Thumbnail reddit.com
1 Upvotes

r/better_claw • • 4d ago

I ran the same agent on Hermes Cloud, a $7 VPS, and BetterClaw for 10 days. Here’s every dollar and everything that broke.

1 Upvotes

There are about 25 threads across Reddit and HN right now asking some version of “where should my agent live?” The answers are always the same three buckets: managed cloud (Hermes Cloud, BetterClaw), a cheap VPS (Hetzner, Oracle free tier, Hostinger), or your own hardware. Lots of opinions. Very few numbers.

So I set up the same agent on all three and let it run for 10 days.

The agent

Same task on every platform. A morning briefing cron at 8am (pulls 5 news sources, cross-references against a topic list, sends a Telegram summary). Email triage during the day (20 to 30 Gmail classifications, draft replies for my approval). Ad-hoc Telegram conversations throughout the day. A couple of research tasks.

Same model everywhere: DeepSeek v4.1 Flash via OpenRouter, BYOK. The model bill is the same across all three because it’s my key, my tokens, my cost. What’s different is the platform cost and the experience of living with each one.

Setup time

Hermes Cloud: about 15 minutes. Sign into Nous Portal, pick the $20/month Plus plan (includes one cloud agent), connect Telegram, paste the OpenRouter key, write the morning briefing task. The Telegram bot uses Nous’s shared Team Gateway, which means you don’t configure your own. That’s convenient until you want something custom (more on that later).

Hetzner VPS (CX22, $7.11/month): about 3.5 hours. Spin up the server, SSH in, install Docker, pull the OpenClaw image, configure environment variables, lock the gateway to loopback, set up SSL, connect Gmail OAuth (which needs a Google Cloud project, credentials JSON, redirect URIs), connect Telegram via BotFather, write the SOUL.md, set up the morning cron, test everything. I’ve done this before so 3.5 hours is probably fast. A first-timer? The r/openclaw threads estimate 4 to 6 hours for Telegram alone, and one person said 60 hours total to get comfortable.

BetterClaw: about 8 minutes. I timed it. Sign up, paste OpenRouter key, one-click Gmail OAuth (no Google Cloud project needed, BetterClaw handles it natively), create Telegram bot and paste token, write the morning briefing in the visual builder, hit start. Hardest part was waiting for the BotFather confirmation message.

10-day platform cost (not counting the model bill)

Hermes Cloud: $5.10 over 10 days. That’s on the $20/month Plus plan, which works out to about $0.67/day. But the agent doesn’t charge the full $0.67 if it’s idle. Hermes Cloud bills per-second for compute and a flat rate for storage. On days I barely used it (weekends), the charge dropped to about $0.15. On heavy days, it was $0.60 to $0.70. The $20 plan includes credits, so I didn’t pay anything extra on top. But the billing dashboard is confusing. I still can’t tell you exactly when the agent is “idle” versus “running but waiting.” People in r/hermesagent keep asking the same question (“is $0.51/day the rate regardless of usage?”) and the answers are half-guesses even from Nous staff.

Hetzner VPS: $2.37 over 10 days ($7.11/month flat, prorated). The cheapest by far. It runs whether or not the agent is doing anything, which means you pay the same on a quiet Sunday as a busy Monday. No surprises, but also no scaling.

BetterClaw: I ran this on the paid tier. Cost over 10 days was $3.20. Like Hermes Cloud, it bills by usage, not flat rate, so quiet days were cheaper.

What worked

On all three platforms, the morning briefing arrived at 8am every day. Email triage ran without issues. Telegram conversations worked. The core agent functions are the same because the agent does the same thing regardless of where it lives.

The differences show up in everything around the agent.

Hermes Cloud was the smoothest Hermes experience I’ve had. No Docker, no gateway config, no SSL, no firewall. The agent just runs. If you’re already in the Hermes world and you want to stop managing infrastructure, this is the obvious move. The Telegram integration uses their shared gateway, which means setup is faster but you can’t customize the bot as much.

The VPS gave me the most control. I could SSH in, check logs, edit config files, install whatever I wanted, run other things alongside the agent. If something broke, I could see exactly why. If I wanted to add a second agent, I just spin up another container. No permission to ask, no plan to upgrade.

BetterClaw was the least time I spent thinking about infrastructure. The 8-minute setup isn’t a gimmick. Gmail OAuth without a Google Cloud project is a real time-saver (that step alone took me 40 minutes on the VPS). The trust levels (Intern, Specialist, Lead) meant the agent started in draft-only mode and I promoted it after a few days of checking its work. I didn’t configure that. It was just there.

What broke

Hermes Cloud: on day 4, I wanted to add a custom Telegram command that triggers a specific research task. On a VPS, I’d edit a config file and restart. On Hermes Cloud, I couldn’t find a way to add custom commands without going through the Hermes skill system, which is more complex than editing a file. I got it working on day 5 after reading the docs more carefully, but it felt like working around the platform rather than with it. Also, the Privacy Mode question still bugs me. Nous says it covers inference payloads. What about memory files, conversation history, connected account data? A Nous staffer in r/hermesagent escalated it to the team. That was in October. I haven’t seen a clear answer.

The VPS: an OpenClaw update on day 6. I had pinned to a stable version, but I wanted to test the 2026.11.1 patch that fixes false Telegram message refusals (which I was hitting). The update took about 45 minutes because the migration rewrote some model settings and I had to check each one. During those 45 minutes, the agent was down. Emails queued. Morning briefing didn’t fire. The HVAC owner from r/openclaw who runs a second Mac Mini just for updates suddenly made a lot more sense to me.

I also had a DNS blip on day 8 that killed the Telegram listener. It reconnected on its own after about 20 minutes, but during that window, messages I sent to the bot went into a void. No alert. No notification. I found out because I sent a test message and got nothing back. On a managed platform, you’d expect monitoring to catch that. On a VPS, you’re your own monitoring.

BetterClaw: less customization than the VPS. The SOUL.md equivalent exists but it’s simpler. I couldn’t fine-tune the agent’s personality to the same depth as raw OpenClaw. The agent felt capable but a bit more generic. Also, the memory on the tier I used only retains 14 days, so anything from the beginning of the test was already starting to age out by the end. On the VPS with OpenClaw, memory is unlimited (limited only by disk space). On Hermes Cloud, memory is persistent as long as the agent runs.

The numbers people actually want

Setup time: Hermes Cloud 15 min, VPS 3.5 hours, BetterClaw 8 min.

Platform cost (10 days): Hermes Cloud $5.10, VPS $2.37, BetterClaw $3.20.

Downtime I noticed: Hermes Cloud 0, VPS about 65 minutes (45 min update + 20 min DNS), BetterClaw 0.

Time I spent on maintenance: Hermes Cloud about 30 min (the custom command), VPS about 2.5 hours (update, DNS investigation, log checking), BetterClaw about 5 min (one SOUL.md edit).

Gmail OAuth setup: Hermes Cloud handled by platform, VPS 40 min (Google Cloud project), BetterClaw one-click.

Custom Telegram commands: Hermes Cloud possible but not obvious, VPS edit a file and restart, BetterClaw through the visual builder.

Who should use what

You want the cheapest option and you’re comfortable with Docker, SSH, SSL, OAuth, and being your own sysadmin: the VPS. $7/month flat. Full control. Full responsibility. The update pain and silent failures are real, but if you enjoy tinkering (or at least don’t mind it), this is the most capable setup.

You’re already using Hermes and you want to stop managing infrastructure: Hermes Cloud. The $20/month Plus plan is more than a VPS but less than your time. Setup is fast, uptime was perfect during my test, and the agent runs the same Hermes you already know. The billing confusion and privacy-mode ambiguity are the rough edges.

You want a working agent by lunch and don’t want to think about infrastructure again: BetterClaw or any managed OpenClaw platform. 8-minute setup is real. The one-click OAuth is real. The trade-off is less customization depth and time-limited memory on some tiers. If your agent does standard stuff (email triage, briefings, conversations, research), you won’t notice the ceiling. If you want to build custom integrations and hack on config files, you’ll hit it.

You want the best of everything: honestly, there isn’t one. I kept the VPS running after the test because I like having SSH access. I also kept BetterClaw running for a second agent that does simpler work where I don’t want to think about it. Two platforms, two agents, different jobs.

What I’m checking next

The Hermes Cloud billing dashboard. I want to understand exactly when “idle” means no charge versus storage-only charge. If anyone from Nous has the breakdown, I’ll update this.

The OpenClaw 2026.11.2 release. It’s supposed to fix the job-scheduling regression and the fallback model lock that hit in 10.10. If it does, the VPS update story gets less painful.

BetterClaw memory retention on higher tiers. I tested one tier. If longer memory changes the experience meaningfully, that’s worth a follow-up.

Will report back in December.

Running your agent somewhere I didn’t test? Drop your setup and what it costs below. Especially interested in Oracle free tier, Hostinger managed Hermes, and Raspberry Pi setups.


r/better_claw • • 4d ago

Tested every free LLM provider on an actual AI agent. Nov 2026 update.

7 Upvotes

I wrote a version of this in June. A commenter pointed out I got the Gemini Flash limit wrong (it’s 500 requests/day, not 1,500). Fair enough. A few providers changed their limits too. So I re-ran the whole thing.

Same setup as last time. One OpenClaw agent doing the boring stuff I actually use it for: morning news briefing at 8am, email triage (sorting 20 to 30 emails and drafting replies), random Telegram conversations during the day, and a couple of research tasks. That’s about 800 to 1,200 requests on a normal day.

I ran each provider for a workweek, Monday to Friday, and just swapped the API key each time.

Every number below was checked against provider docs on November 8. At least one will be wrong by the time you read this. That’s the game.

The ones that didn’t make it to lunch

OpenRouter without the $10 deposit. 50 requests a day. My morning briefing used 8. Email triage ate 25 more. By 10am I had 17 left and two research tasks queued. That’s not a free tier, that’s a sample cup at Costco.

The fix is the same as June: drop $10 into your account (your money, withdraw anytime, never gets spent). Limit jumps to 1,000 requests on free models. The $10 just proves you’re a person and not someone’s rogue cron job.

Together.ai still gives you $5 of credit and calls it a free tier. My agent burned through it in 2.5 days. When it’s gone, you pay. A free trial in a free tier trenchcoat.

Anthropic and OpenAI still have no real free API tier. If someone tells you to “just use the free Claude API” they mean the chat app, which has limits and no programmatic access. Don’t build on that.

The ones that lasted a day (barely)

Groq on Llama 3.3 70B. The speed is genuinely wild. 300+ tokens per second. Your agent responds before you finish reading the question. But the daily cap is 100K tokens on the 70B model, and that’s the number that runs out first. At 3,000 to 5,000 tokens per conversation, I was locked out by early afternoon. Like owning a Ferrari that only has a 2-gallon tank.

On the smaller 8B models, Groq gives you 14,400 requests a day, which is absurd amounts of headroom. The trade-off: 8B models are fine for classification and simple stuff but they get confused on anything multi-step. Good enough for background tasks, not for conversations you care about.

Gemini 2.5 Pro free tier. 50 requests a day. Gone in under 2 hours. Use Flash instead. Seriously, I don’t know why people try this one.

The ones that got me through the week (with some rationing)

OpenRouter with the $10 deposit. 1,000 requests a day across 30+ free models. DeepSeek R1, Llama 3.3 70B, Qwen3 Coder 480B, GLM-5.3 Flash, Gemini Flash. All $0 per token. I made it to Thursday comfortably and started rationing on Friday.

The thing I like about OpenRouter is optionality. One model is down? Swap to another in one config line. DeepSeek for reasoning, Qwen for coding, Llama for long context. It’s like having a bench of free players.

The thing that bites: 20 requests per minute cap. Your agent fires 25 tool calls in a row during a research task and you get 429'd. Fine for chat, annoying for anything complex.

NVIDIA NIM. New since June. Free Nemotron models, and some of them are surprisingly capable. I had 3 good days and 2 days where rate limits made it basically unusable. No warning, no pattern I could see. Worth keeping in your back pocket as a fallback, not something to build your daily workflow on.

The ones I forgot I wasn’t paying for

Groq on 8B models (yes, again). 14,400 requests a day. I ran the full week without hitting the limit once. If you route only the boring stuff here (heartbeat checks, cron polls, email classification, quick lookups) and save a better model for conversations, this tier is invisible. My busiest day used about 900 requests. The ceiling is so far away you stop thinking about it.

Cerebras. About 1 million tokens a day. No credit card. Their hardware is fast (up to 2,000 tok/s on some models). I used 410K tokens on my busiest day and 180K on the lightest. Never came close. Model selection is narrower than OpenRouter (mostly Llama, Qwen, DeepSeek) but the raw volume is the most generous of anything I tested.

Mistral Experiment. About 1 billion tokens a month. Read that number again. It’s absurd. The catch is the catch: your prompts, your conversations, everything gets used for model training. For a personal agent reading your email and calendar, that’s a real trade-off. For non-sensitive stuff like news summaries and research, honestly most people won’t care.

Google AI Studio, Gemini 2.5 Flash. This is still the one. 500 requests a day (down from the 1,500 I wrongly claimed in June, sorry about that). My busiest day used 341 requests. Quietest day, 95. Never hit the wall.

15 requests per minute is the only limit that matters. If your agent does 20 rapid tool calls, you’ll feel it. For normal use, invisible.

And the 1M token context window on the free tier is just unfair to everyone else. Most free tiers give you a tiny window. Google gives you a million tokens. Process entire documents without chunking. It’s the kind of thing you don’t appreciate until you switch to a provider that makes you split a 50-page PDF into chunks.

One thing I missed in June: Google AI Studio also gives you Gemma 4 31B and Gemma 4 26B a4b at 1,500 RPD each, with no token-per-minute cap. If your agent doesn’t need Gemini-level reasoning, these are quieter and have higher limits.

Google’s free tier may use your prompts for training (paid tier and Vertex don’t). Same deal as Mistral, but at least there’s an upgrade path where you keep the same provider.

What changed since June

Gemini Flash dropped from 1,500 to 500 RPD. Still the best free tier, but the gap to Cerebras got smaller.

NVIDIA NIM showed up and is worth having as a fallback.

OpenRouter added more free models (GLM-5.3 Flash, Qwen3 Coder 480B). The $10 trick still works.

Ollama Cloud launched a free tier. I didn’t include it in the main ranking because it needs Ollama-specific setup, but if you already run Ollama locally, it’s worth a look as a remote fallback.

Together.ai still calls a trial a free tier. Sambanova still changes limits without telling you (I didn’t re-test it because of this and I’d rather tell you that than guess).

Being honest about what free can’t do

Free models are not Opus 5.5 or Sonnet 5.5. My email agent misclassified 4 out of roughly 130 emails on Gemini Flash that it would have gotten right on Opus. Research summaries were shallower. Telegram conversations were less sharp. You can feel the difference.

Rate limits make complex tasks painful. Anything that fires 15+ API calls in quick succession (search, fetch, summarize, cross-reference, draft) hits the RPM wall on most free tiers. You either wait between steps or accept a simpler result.

Free tiers go down. NVIDIA NIM had 2 bad days out of 5 during my test. OpenRouter’s free models occasionally return errors when a provider behind them is overloaded. Gemini was the most stable, but one bad morning would have broken my 8am briefing.

And none of these providers guarantee your data isn’t used for training on their free tier. If your agent handles client names, financial data, health info, anything sensitive, pay for a provider with a clear data policy or run a local model.

The stack that actually works at $0/month

Don’t pick one. Stack them.

Google AI Studio (Gemini Flash) as your daily driver. 500 RPD, 1M context. Handles morning briefings, email triage, conversations, research.

Groq on 8B for background tasks. 14,400 RPD. Heartbeat checks, cron polls, simple classifications. Fast and free.

OpenRouter with the $10 deposit as your fallback. 1,000 RPD across 30+ models. When Gemini is down or you need a different model for a specific task.

Cerebras for heavy batch work. 1M tokens/day. When you need to chew through a big document or run an expensive research job.

Combined: roughly 16,000+ requests a day. More than any personal agent needs. The only money that touches your card is the $10 OpenRouter deposit, and it never gets spent.

The honest caveat

Start free. See if having an agent is even useful for your life. If it is, $3 to $5/month on DeepSeek API or a $10 OpenCode Go subscription for the 20% of tasks that actually need a better model is the smartest upgrade path.

Most people discover that 80% of what their agent does runs fine on free models. The other 20% is where you spend selectively.

Every number was checked the week of November 8, 2026. By the time you read this, at least one has changed. Check before you build.

What providers am I missing? If you’re running an agent on a free tier I didn’t cover, drop it below and I’ll add it to the next update.


r/better_claw • • 7d ago

Split my agents across Opus, DeepSeek and Codex for 2 weeks. cost breakdown and where it broke.

0 Upvotes

I was running all my agents on Opus 5.5. Planning, execution, everything. My bill last month was $340 across three agents handling email triage, a research cron, and ad-hoc Telegram conversations. Most of that spend was Opus doing repetitive work that didn't need Opus.

So I split them. Opus 5.5 as the planner. DeepSeek v4.1 Flash as the worker. Codex as the reviewer. Same tasks, same agents, same two weeks. I tracked every dollar and every failure.

The setup took about 45 minutes to reconfigure, and the bill dropped from roughly $340/month pace to about $95/month pace. But it wasn't free of problems. Here's everything.

The method.

Three agents, all running on BetterClaw with BYOK keys. Each agent got a different model assignment:

Agent 1, email triage: reads Gmail overnight, classifies messages, drafts replies for my approval, sends the approved ones. Moved from Opus to DeepSeek v4.1 Flash for classification and drafting. Opus still handles anything the classifier flags as complex.

Agent 2, research cron: runs at 7am, pulls news from 5 sources, cross-references against a topic list, writes a summary, sends to Telegram. Moved entirely to DeepSeek v4.1 Flash. The planning step (which sources, what to look for) is baked into the cron config, so the model just executes.

Agent 3, Telegram conversations: ad-hoc questions and tasks throughout the day. Kept on Opus 5.5 for planning and reasoning. DeepSeek handles follow-up execution when Opus hands off a clear task. Codex reviews any output before it leaves the system (emails, posts, anything external).

I tracked costs through the provider dashboards: Anthropic for Opus, DeepSeek's billing page, and OpenAI for Codex. Checked daily for the first week, then every other day.

Week 1 costs.

Opus 5.5: $31.40. Down from roughly $78/week when it was doing everything. The drop came from removing it from email classification (which was 60%+ of its old token burn) and research summarization.

DeepSeek v4.1 Flash: $8.20. This covered all email triage (about 25 to 35 classifications per day, plus draft generation) and the full research cron. Off-peak runs (the 7am cron hits DeepSeek's cheaper window) saved roughly 40% on the research agent.

Codex: $4.60. Review-only. It checked 47 outbound items (email drafts, one research summary per day, a few Telegram outputs I flagged for review). Most reviews were fast because the output was already shaped by the planning step.

Week 1 total: $44.20. Previous pace on all-Opus would have been about $78.

Week 2 costs.

Opus: $27.80 (lighter Telegram week, fewer complex conversations).

DeepSeek: $9.10 (one day had 48 emails instead of the usual 25 to 30, a mailing list spike).

Codex: $3.90 (fewer outbound items to review).

Week 2 total: $40.80.

Two-week total: $85. Projected monthly: roughly $170. Previous monthly pace: roughly $340. That's a 50% cut with the same agents doing the same work.

Where it worked well.

Email triage on DeepSeek was indistinguishable from Opus for classification accuracy. I spot-checked 50 classifications across the two weeks. DeepSeek matched what Opus would have categorized on 48 of 50. The two misses were both edge cases (an email that was half personal, half work) where the classification was defensible either way.

The research cron was actually faster on DeepSeek. Opus used to take 90 to 120 seconds on the morning summary because it would reason about source quality and weigh alternatives. DeepSeek finished in 30 to 45 seconds because the plan was already in the cron config. It just executed. The output quality was slightly less nuanced (fewer "this contradicts what source B says" observations) but the core summary was solid.

Codex as reviewer caught 7 issues in 94 reviewed items across two weeks. That's a 7.4% catch rate. Three were tone problems in email drafts (too formal for the recipient). Two were factual errors in research summaries (a date wrong, a company name misspelled). Two were formatting issues. Nothing catastrophic, but things I would have sent out without the review step.

Where it broke.

DeepSeek draft quality on complex emails was noticeably worse. When an email needed nuance (declining a meeting without offending someone, explaining a technical decision to a non-technical person), DeepSeek's drafts were flat. They got the facts right but missed the tone. I ended up routing these back to Opus manually after the first three days. That's where the "Opus for complex, DeepSeek for routine" split needs to be set per task, not per agent.

Handoff latency added up. When Opus planned a task and handed it to DeepSeek for execution, there was a 2 to 4 second gap. On a single task, invisible. On a Telegram conversation where Opus plans, DeepSeek executes, and Codex reviews before responding, the round trip was 8 to 12 seconds. Noticeable. Not painful, but I could feel the pipeline. On all-Opus, the same response took 4 to 6 seconds.

Codex review added cost without always adding value. Of the 94 reviews, 87 passed with no changes. That's 87 times I paid for a Codex call that returned "looks good." The 7 catches were worth it. But the 87 no-ops mean I'm paying a tax on every outbound item. A smarter setup would route only high-stakes items (external emails, anything public-facing) through review and skip it for internal summaries.

DeepSeek had one outage during the two weeks. Tuesday of week 1, about 3 hours starting around 2pm UTC. My email triage agent queued messages but couldn't process them until the API came back. On all-Opus, I never had an outage during the test. Single provider means single point of failure, but it also means one provider to monitor. Multi-provider means I need to watch three dashboards, and an outage on any one of them degrades part of the system.

The model switching itself was easy. Changing a model on BetterClaw took about 30 seconds per agent (settings, pick from dropdown, save). On a self-hosted OpenClaw or Hermes setup, you'd be editing config files and restarting services. On a Hermes setup with OpenRouter, you'd change the model string in your provider config. The switching part isn't the hard part. Knowing which tasks to move is.

What I'd change if I did this again.

Route by task complexity, not by agent. My initial split (email agent gets DeepSeek, Telegram agent gets Opus) was too coarse. The real split should be: routine classification and execution on DeepSeek, anything requiring tone judgment or multi-step reasoning on Opus, review only on items leaving the system to external recipients.

Skip the review step on low-stakes output. Internal summaries, cron logs, notes to self. The 87 no-op reviews cost about $3.50 over two weeks for zero value. Review the things that matter and let the rest through.

Set up a fallback, not just a split. If DeepSeek goes down, email triage should fail over to Opus automatically, not queue until the API recovers. I didn't configure this and it cost me 3 hours of delayed email processing. That's the next thing I'm building.

Track token usage per task type, not just per agent. My dashboard showed me cost per agent. What I actually needed was cost per task type (classification, drafting, summarization, conversation). That would have told me faster which tasks to move off Opus.

Who this makes sense for.

You run multiple agents and your bill is over $100/month: split your execution tasks to DeepSeek or Qwen Flash and keep Opus for planning and complex reasoning. You'll probably cut 40 to 60% depending on how much of your workload is routine.

You run one agent on one model and your bill is under $50/month: probably not worth the complexity. The savings won't cover the time you spend configuring and monitoring a multi-model setup.

You're on a self-hosted Hermes or OpenClaw setup with OpenRouter: you can do the same split by setting different model strings per task in your config. The principle is the same. The tooling is different.

You want to try this without reconfiguring anything: start by just adding a review step. Keep your current model for everything, add a Codex or Sonnet review on outbound items only. See if the review catches anything. If it does, then consider splitting execution to a cheaper model. One step at a time.

The two-week numbers.

All-Opus projected monthly: roughly $340. Split setup projected monthly: roughly $170. Savings: roughly $170/month, 50%. Quality issues caught by review: 7 of 94 (7.4%). Classification accuracy on DeepSeek vs Opus: 48 of 50 matched (96%). DeepSeek outage during test: 1 (3 hours, Tuesday week 1). Handoff latency on multi-model pipeline: 8 to 12 seconds vs 4 to 6 seconds on single model. Time to reconfigure: 45 minutes.

I'm running this setup into December to see if the numbers hold over a full month and whether the DeepSeek outage was a one-off. I'll also add the per-task-type cost tracking and the automatic fallback. Will post the update.


r/better_claw • • 7d ago

Openclaw Broke Fallback Models across providers

Thumbnail reddit.com
1 Upvotes

r/better_claw • • 8d ago

The hidden costs of a "free" self-hosted agent, from the people running them

5 Upvotes

A post hit 1,438 upvotes on r/AgentsOfAI this week. Someone shared their "Ultimate free AI setup": Hermes Agent as the harness, DeepSeek v4.1 Flash as the model, Ollama + Qwen3-8B as the local fallback, OpenWhispr for voice, Obsidian for notes. At the bottom: "Total cost: £0."

The top comment, 44 upvotes: "Total cost Zero??? What about the freakin hardware it runs on????"

And that comment opened up a conversation I've been wanting to have for a while. Because "free" is the most expensive word in self-hosted AI.

The costs people reported this week

I went through five subreddits this week. Here's what people running their own agents are actually spending. Not estimates. Numbers from real users.

Hardware. One user on r/hermesagent runs Hermes 24/7 on a 64 GB Mac Studio. That's a $2,000+ machine dedicated to one agent. An HVAC business owner on r/openclaw bought a second Mac Mini ($700) just to handle updates on his first one. On r/LocalLLM, someone built a cluster of 8 DGX Sparks for about $58,000. On r/AgentsOfAI, a commenter pointed out that a $19,500 local rig costs more than 5 years of running a better model in the cloud.

Subscriptions people pretend don't count. The Hermes power user on r/hermesagent pays $200/month for Claude Max and $200/month for ChatGPT Pro, plus pay-as-you-go DeepSeek on top. That's $400/month before the hardware. Someone else runs it on a Pi 4 with "free-tier models behind OpenRouter" and still hits API limits.

Time. This one showed up everywhere. A commenter on r/AgentsOfAI did the math: "Hours to search, download and install that: 100. Hours to update: 20 monthly. Programmer's hour fee: from $50." Someone else on r/openclaw said they spend their Saturdays fixing their agent instead of using it. On r/hermesagent, a user admitted: "I'm embarrassed to say how many times I have installed and uninstalled Hermes, because I felt so lost." Another said: "I feel like I restart the set up every week."

Electricity. A user on r/LocalLLM built a 24-GPU rig running Qwen 3.8 Flash Next. Idle power: 200W. Under load: 1,500 to 1,800W. He said the heat warms two floors of his house. Which is nice in November. Less nice in July.

The update tax. On r/openclaw, OpenClaw 2026.10.10 broke every chat turn for one user. 11 out of 11 failed. The SQLite worker hit a hard-coded 512 MB memory cap on his 1 GB session database. The community's standard fix now is to run a second agent (Codex, Hermes, Claude CLI, or another OpenClaw) whose only job is to upgrade the first one. When you need two agents to keep one agent running, "free" is doing a lot of heavy lifting.

Networking. On r/hermesagent, new users kept asking how to reach their agent from their phone. The answers: set up a Cloudflare tunnel, or install Tailscale, or run a VPN. One person replied: "So it's an alternative to telegram... but you have to use tailscale?" Another had duplicate Telegram gateways on their laptop and VPS "fighting over messages."

The cost people don't put a number on

There's a comment from r/n8n that stuck with me. Someone said Hermes would be "a nightmare to get approved in a regulated environment" because it has no audit logs, no run history, no approval trail. n8n gets approved because "we track every single run and all failed cases as a default."

If you're using an agent for anything real, like the HVAC owner dispatching techs or the guy running A/R reconciliation, the cost of a silent failure is real money. An OpenClaw update broke Telegram and Discord message delivery this month. Messages looked like they sent. They didn't. The patch that fixed it had to add a nonzero exit code because Doctor was reporting failed inspections as success.

How long does a silent failure run before you notice? That's a cost too.

What "free" really means

I'm not anti-self-hosting. People self-host for good reasons. Privacy. Control. Learning. The satisfaction of building something that works. The HVAC owner on r/openclaw replaced a secretary and a dispatcher with his setup and says it's worth every frustration.

But "free" isn't one of those reasons. Because the actual cost of a self-hosted agent looks something like this:

The hardware you bought or repurposed. The API keys you're paying for. The 20 hours a month keeping it updated. The electricity. The networking setup. The weekend you lost to an update that broke everything. The customer message that didn't go out and you didn't know for three days.

Add it up and it's not zero. For most people it's somewhere between $50 and $500 a month, depending on how much you value your time and how much your agent actually does.

Where managed hosting fits

At BetterClaw, we charge for the hosting and add zero markup on your API keys. You bring your own key, pick your own model, and pay the provider directly. What you get is someone else dealing with updates, containers, networking, monitoring, and the 3 AM question of "is my agent actually running or just not throwing errors."

That's not for everyone. If you run a homelab because you love running a homelab, managed hosting takes the fun out of it. If you're on a Pi 4 with free-tier models and $0 is actually the constraint, that's real and a hosted service doesn't solve it.

But if you're the person who spent Saturday fixing an update instead of using your agent, or the person who bought a second computer to babysit the first one, or the person who's restarted the setup every week for a month, the math might be different from what you think.


r/better_claw • • 8d ago

An agent wiped ~/Library on a Mac.

1 Upvotes

This happened two days ago. A thread on r/ClaudeCode hit 3,273 upvotes and over 1,400 comments.

Someone ran Opus 5.5 with --dangerously-skip-permissions and walked away. The agent was cleaning up test files under ~/Library/Application Support/. There's a space in that path. The tool it used, xargs -n1 dirname, split the path at the space. So instead of targeting the right folder, the agent ran rm -rf on ~/Library. For about two minutes. App data, passwords, macOS configs. Gone.

No backups.

The top comment (1,180 upvotes) was basically: "Oh look, another thread about Claude doing something dangerous... yes, I was running with --dangerously-skip-permissions. Ah."

And that's where most people stopped reading. But the useful part of the thread was below that.

What 1,400 comments actually agreed on

The consensus wasn't "don't use agents." It wasn't "agents are too dangerous." It was something more specific:

The environment is the safeguard. Not the approval prompts.

One comment put it clearly: "An agent runs thousands of bash commands a day. You can't review all of them. It's the environment that hasn't been properly set up to keep things safe."

Here's the setup people converged on:

1. Block destructive commands at the hook level. One user said they've had a hook blocking every variation of a delete command for 6 months. The agent can't rm, rmdir, or unlink anything. It's forced to move files into a cleanup folder. The user reviews what's in there and deletes manually. Six months, zero incidents.

2. Run the agent as its own user. Give the agent a user ID with permissions scoped to the project directory. It literally can't touch anything outside that tree. If it tries to rm -rf ~/Library, the OS says no before the agent even knows what happened.

3. Containers. Docker, OrbStack, whatever. The agent works inside a sandbox. The host filesystem is mounted read-only or not at all. If the agent wipes everything inside the container, you rebuild the container. Your actual machine is untouched.

4. Don't skip permissions. Use selective hooks instead. The shower meme post (2,528 upvotes, same week) showed the other side of this: people hate sitting there approving every command. The middle ground is hooks that auto-approve safe actions (file reads, git status, test runs) and pause only on risky ones (pushing to remote, deleting files, running unfamiliar scripts). You get unattended work without unattended destruction.

The thread had a second conversation running underneath the safety one. Someone asked: "What about the agents running on your server 24/7? The ones managing your email, your scheduling, your customer messages?"

Those agents have the same problem, and most of them have fewer safeguards than Claude Code. OpenClaw agents on a VPS have root access by default. Hermes agents on a homelab can reach anything the host can reach. Most people running always-on agents have zero hooks, zero delete blocks, and zero isolation.

The Claude Code thread got attention because it was dramatic and because 490,000 people are in that sub. But the same risk exists for every agent running on bare metal with full shell access. The only difference is scale of damage and whether anyone notices.

What this means for how we run agents

The safety model that came out of this thread is pretty simple:

Agents should run in environments where the worst thing they can do is waste tokens. Not delete your passwords. Not wipe your configs. Not send emails you can't unsend.

That means containers, scoped permissions, approval gates on anything irreversible, and a cleanup folder instead of rm.

At BetterClaw, every agent runs in its own container. It can't touch other agents' data. It can't reach the host. Actions that leave the system (sending a message, posting content, triggering a webhook) go through an approval step unless you explicitly allow them. That's not a feature we added after reading this thread. It's how managed hosting works when you assume agents will eventually do something stupid, because they will.

But you don't need us to do this. If you're self-hosting, the 4-layer setup above works. The point isn't who hosts the agent. The point is that an agent with unrestricted shell access on your personal machine is a bad idea, and 3,273 people just agreed on why.


r/better_claw • • 8d ago

How to install and use?

Thumbnail reddit.com
1 Upvotes

r/better_claw • • 11d ago

Self-Hosted AI Agent Workspace (MIT) – One-Click Deploy via Vercel

Post image
1 Upvotes

r/better_claw • • 11d ago

Don't think twice, it's alright

Thumbnail
reddit.com
1 Upvotes

r/better_claw • • 12d ago

A $/min limit didn't stop my looping agent. It just restarted every minute. Here's the fuse I built instead.

2 Upvotes

Disclosure: I build Cognocient AI, an LLM cost proxy. The approach works however you build it.

Dollars-per-minute limits have a gap. A looping agent hits the limit and gets blocked, the window resets, and it runs again until it trips again. You still pay for every lap, all day.

Four changes closed that gap:

  1. Sliding window, not clock minutes: Spend goes into 1-second buckets and is summed over the last 60 seconds, so $40 spent from 12:00:50 to 12:01:10 counts as $40, not two lots of $20.

  2. A short burst window: An optional limit over the last 10 seconds (5-59s) catches a fast loop long before the minute total does.

  3. A latched fuse: Once a limit trips, every call on the key is refused for 5 minutes (you can change it), even after the rate drops. Refused calls don't count as spend. The 429 carries Retry-After with the real time left. There's a manual reset for after you've killed the loop.

  4. Per-run limits: If 10 agents share a key, a key-wide trip stops all 10. Tag each run with an X-Cost-Run-ID header and give each run its own $/min. Only the runaway run stops.

There is also a warning at 50% of the limit, so you hear about it before anything is blocked.

What it cannot do: calls already in flight when the fuse trips still finish and get billed. Everything else is checked before the call is sent, using its worst-case cost from max_tokens.

Docs with the defaults and the 429 format: https://www.cognocient.com/docs/guardrails#spend-fuse-burst-limit-and-early-warning

How do you size the limit? I default the fuse to 5 minutes, and I am not sure that is right for long-running agents.


r/better_claw • • 13d ago

Your agents can’t see each other’s work. We built Projects to fix that. Still not sure about shared memory.

Post image
2 Upvotes

A lot of you came here from running OpenClaw, Hermes or your own stack, so I'll skip the marketing and get into how this works.

The problem we kept hitting

One agent per workspace is fine until you have more than one stream of work. Then you either get one agent with a bloated context juggling everything, or several agents that can't see each other's work, and you end up copying output between chats by hand. Anyone who has tried to get two self-hosted agents to cooperate knows the glue code gets ugly fast.

What Projects is

A project is a shared channel where people and agents sit together. The screenshot is our actual internal project (names blurred): Support, Coder, Social, SEO, Researcher and Design agents, plus four of us.

  • Each agent keeps its own setup. Its own soul.md, memory, skills, connectors and model. Support can run on a cheap fast model while Coder runs on something heavier. Still BYOK, still zero markup.

  • Work is routed by u/mention**.** You tag an agent with a task, it picks it up as a thread with its own status (idle, working, needs you, done). In the screenshot, u/support finds a customer ticket in Help Scout, reads the full history and drafts a reply.

  • Agents can hand work to each other. A research agent can pass findings to a writing agent without a human relaying it.

  • Approval gates on actions that leave the system. Drafts, not sends, unless you allow it. Our support agent never emails a customer on its own.

  • Project-scoped files and context. The files and connected accounts in a project stay in that project, so client A's data doesn't leak into client B's agent.

Under the hood it's the same OpenClaw-style workspace you already know: soul.md, MEMORY.md, daily logs, hybrid memory search, and a flush before compaction. Each agent still runs in its own container.

What we're still deciding (and where we'd love your take)

  1. Shared vs isolated memory. Right now each agent's memory is its own, and the project shares files. Should agents in a project also share a common memory layer, or does that just recreate the bloated-context problem?

  2. Handoff format. Free-text handoffs are flexible but lossy. Structured handoffs (task, inputs, expected output) are reliable but rigid. What has worked for you in your own setups?

  3. Who decides who does what. Auto-assignment by a lead agent, or always explicit u/mentions? We lean explicit because it's easier to debug.

Projects is in beta with a few testers now and opens to everyone next week.

If you've built multi-agent setups yourself, I'd love to hear what broke for you. That's the stuff we want to get right before launch.


r/better_claw • • 13d ago

OpenClaw is a massive waste of time" post hit 162 upvotes. I get why. I still disagree.

2 Upvotes

There's a post making rounds on r/openclaw right now. 162 upvotes, 132 comments. Someone called OpenClaw "a massive waste of time" and said to "look for literally any alternative." And I've been sitting with it for a day because I can't just scroll past that.

I get it. I do.

Every update breaks something. Gateways disconnect and you don't find out until a customer texts you and gets nothing back. You spend a Saturday fixing your agent instead of doing the thing the agent was supposed to do for you. That's all real. A lot of you have been there. I've been there.

But "massive waste of time" is where I stop agreeing.

There's an HVAC business owner who posted this week about running OpenClaw as his dispatcher. It texts his customers, handles warranty questions, coordinates his techs. His one complaint? Updates are, in his words, "brutal every time." He's running a second Mac Mini just so one can update the other. That's a $700 workaround for a software update problem. It's ridiculous.

But he's also replaced a secretary and a dispatcher with it. His business runs differently now. That's not a waste of time. That's a tool with sharp edges that still cuts.

And he's not the only one. There are people in this sub running agents that do their A/R reconciliation, send postcards to customers, run health checks at 3 AM, handle booking on their website. Real workflows. Real money saved. Not "I set up an agent to summarize my emails" demos.

The frustration in that post isn't wrong. The conclusion is.

Here's what's actually broken

Updates. That's 80% of it. The SQLite schema change from version 8 to 10 made rollback nearly impossible. openclaw doctor --fix doesn't catch everything. Four of the top five posts in r/openclaw this week mention update pain. This isn't a loud minority. It's the majority experience.

Gateway and channel disconnects that fail silently. Your agent looks fine. Dashboard shows green. But texts aren't going out, webhooks aren't firing, and you only find out when someone on the other end tells you. That's the kind of failure that makes you question whether automation is worth it at all.

The maintenance tax. Every hour your agent saves you, you're spending 20 minutes keeping it alive. For some setups that math works out. For others it doesn't. And the people where it doesn't work out aren't wrong for being angry about it.

Here's what that post gets wrong

"Look for literally any alternative." Okay. What alternative?

Hermes is the best option if you're technical. r/AI_Agents crowned it this week. But setup is harder, not easier. You're still dealing with VPS, Docker, SSH. And Nous just launched their own managed hosting (Nous Portal) and early users are already reporting gaps. Device access disappearing, push notifications inconsistent. First-party managed hosting and it's still rough.

GrokBot wins for non-technical users. Setup is dead easy. But the moment you start doing anything real, token costs become a problem. Multiple people have called GrokBot pricing "a nightmare" once they're past the honeymoon phase.

The truth is there's no agent platform right now where you just install it and forget about it. OpenClaw's problems are real, but they're not unique. Every platform has a maintenance cost. The question is whether the value exceeds that cost for your specific situation.

What I'd tell someone reading that post right now

If you're in your first two weeks with OpenClaw and that post scared you, take a breath. The first month is the hardest. Most of the people who quit, quit in week two. The setups that survive are the ones that start boring. One agent, one channel, one job. Not a multi-agent orchestration system you saw on YouTube.

If you've been running OpenClaw for months and you're exhausted, that's valid. The update cycle is punishing right now. Pin your version. Take Proxmox snapshots before every update. Skip updates that don't fix something you're actually hitting. "Boring beats broken" isn't a slogan. It's a survival strategy.

If you're ready to quit, ask yourself one question: is the agent doing something useful when it's working? If yes, the problem is maintenance, not the tool. And maintenance is a solvable problem. That's literally what managed hosting exists for, whether it's us at BetterClaw for OpenClaw or Nous Portal for Hermes.

If the answer is no, if the agent isn't doing anything useful even when it works, then yeah. Maybe OpenClaw isn't the right fit. But that's a different problem than what that post describes.

One more thing

162 upvotes on a rant post means people are frustrated. That's worth paying attention to. Not to dismiss, not to argue with. To understand.

But I know a lot of you would push back on "massive waste of time" too. Because you've put in the work, dealt with the broken updates, fixed the silent failures, and come out the other side with something that actually runs your business differently.

That doesn't mean the problems aren't real. It means the tool is worth fighting for. And the people building it and the community around it need to hear both sides, not just the rants and not just the hype.


r/better_claw • • 13d ago

Nous just launched managed Hermes hosting. Here's what happened to the first users.

3 Upvotes

Nous (the team behind Hermes) quietly rolled out their own managed hosting this week. They're calling it Nous Portal, sometimes Nous Cloud. The pitch is simple: skip the VPS, skip Docker, skip the homelab headaches. Just get a Hermes instance that runs.

On paper, this is huge. First-party hosting from the people who build the agent. No more shopping for VPS providers, no more Docker compose files, no more "is my Proxmox config the problem or is Hermes the problem." That question alone has eaten hundreds of hours in r/hermesagent threads.

So what actually happened when people started using it?

The good part

It works. You get a running Hermes instance without touching infrastructure. For the crowd that's been asking "any specific VPS providers you can suggest?" with zero answers for weeks, that's a real solve. Setup friction has been the single biggest thing keeping non-technical users on GrokBot instead of Hermes, and this directly attacks that problem.

The part that isn't good yet

A user on r/hermesagent moved from their own Proxmox server to Nous Portal. Thread got 132 points and 62 comments. Here's what they found:

Device access disappeared. On their self-hosted setup, the Hermes app could reach their phone directly. Device access worked fine. After moving to Nous Portal, the option vanished. Turns out device access requires the agent to reach your phone, and when the agent lives on someone else's server, that direct connection breaks. You'd need a tunnel or bridge back to your home network, and it's not clear if Nous Cloud even supports that.

Push notifications went inconsistent. Self-hosted install had working push. Portal-hosted install doesn't match. A Nous dev confirmed that a push plugin exists for self-hosted users with e2e encryption, and said they'll make it easier. But "will be made easier" and "works right now" are different things.

Sync lag is real. The top comment on that thread asked the team to fix "sync/desync/startup lag." This isn't Portal-specific. It affects every Hermes mobile app. But it hits harder when you're paying for managed hosting and still dealing with lag.

Mobile app beta is a mess right now. TestFlight slots are full. Links show "not found." Someone asked why the app is 250 MB. Three of the top 5 posts in r/hermesagent this week are about the mobile app. People want phone access to their agents and the beta pipeline isn't keeping up.

The tradeoff nobody's saying out loud

Managed hosting always trades control for convenience. That's fine when the convenience covers everything you need. But right now, moving to Nous Portal means giving up device access and getting inconsistent push notifications in return for not running your own server.

For some people that's worth it. If you just want a Hermes instance that responds to text commands and you don't care about phone integration, Portal probably saves you real time and money. VPS costs keep climbing. One user in that thread said their VPS "has gotten expensive." The HVAC owner over in r/openclaw is running a second Mac Mini ($700) just to handle updates on his first one. Infrastructure costs add up fast.

But if you moved to Hermes specifically because you wanted an always-on agent that talks to your phone, controls your devices, and sends you push alerts, Portal in its current state takes away the things that made Hermes worth the switch.

Where we sit on this

We handle OpenClaw, not Hermes, so this isn't a head-to-head comparison. But the problem is the same one we built BetterClaw around. Self-hosted gives you full control and full headaches. Managed hosting gives you convenience but cuts features you didn't know you needed until they're gone.

Our bet with OpenClaw has been that managed hosting shouldn't mean losing functionality. When someone moves to BetterClaw, their agent should do everything it did on their own server, minus the maintenance. That's the standard Nous Portal will need to hit for Hermes users too.

What to watch

This is week one. Nous built Hermes. If anyone can close these gaps, it's them. The dev in that thread is already talking about improvements. The question is how fast. If device access and push stay broken for a month, people will either go back to self-hosting or start looking at alternatives. If Nous ships fixes in the next couple weeks, Portal becomes the obvious default for new Hermes users.

Either way, first-party managed hosting existing at all changes the conversation. "Which VPS should I use for Hermes?" is becoming "should I even run my own server?" And that's a question worth watching.


r/better_claw • • 14d ago

GPU prices up 35%, memory shortage until 2030, and Altman wants your DRAM.

3 Upvotes

Sam Altman said out loud what a lot of people in the cloud business think privately: that it’s “quite terrible” for personal computers to hold scarce DRAM when data centers could use it better.

Let that sit for a second.

The CEO of the company selling you API access to models thinks your local hardware is a waste of resources. And he said it the same week SK Hynix announced the memory shortage could last until 2030 and GPU prices climbed another 30 to 35% in three months.

I don’t think he’s being evil. I think he’s being honest about how he sees the world. And that’s exactly why it matters.

The money behind the quote

Apple just dropped the Mac Studio M5 Ultra with 512GB of unified RAM. The RAM upgrade alone costs $15,500. Total machine is about $22,300. That’s not a consumer product, that’s a down payment on a car.

NVIDIA’s DGX Spark was supposed to be the “accessible” local AI box. Now there are reports of Amazon cancelling DGX Spark orders and closing buyer accounts. Unconfirmed, but Tim Sweeney and other verified names are posting about it. If true, even getting the hardware is becoming a problem, not just affording it.

Meanwhile vLLM just dropped CUDA 12.9 support entirely in their latest release candidate. If you’re running older hardware, you’re not just behind on performance. You’re being actively left behind by the software stack.

The price of running local went up. The complexity went up. The software compatibility window got narrower. And the guy selling the alternative just told you your RAM is wasted on your desk.

Why local still matters even if it’s lil expensive

Here’s where I disagree with Altman, and I disagree hard.

The local AI community isn’t hoarding DRAM because they think it’s fun to spend $22k on a workstation. They’re doing it because the alternative is handing every prompt, every piece of context, every business document to someone else’s server. And every single week there’s a new reason not to trust that.

This week alone: a backdoored Claude Code extension hit 5,000 users through Cursor’s marketplace. Researchers broke out of the built-in browsers in five different coding tools. A grey-market “AI relay” service was caught reselling Codex and Claude Code in Asia with the sandboxes turned off, routing company data through its own servers. Cloudflare disclosed a KV-cache leak where 155 responses contained other customers’ data.

That’s one week.

When someone spends $22k on a Mac Studio to run models locally, they’re not wasting DRAM. They’re buying the only guarantee that their data doesn’t end up in someone else’s cache leak. That’s not irrational. That’s math.

The squeeze is real though

I’m not going to pretend local is getting easier. It’s getting harder.

GPU prices are up 30 to 35% in three months and the supply side isn’t improving. SK Hynix says the memory shortage runs through 2030. Not next year. Not 2028. 2030. That’s four more years of this.

Ollama is doing incredible work bringing local inference to normal hardware. The LFM3 family running at 256K context on a 1.7B parameter model is legitimately impressive. But the ceiling keeps rising. The models people actually want to run keep getting bigger. Mistral just dropped Large 4 at a trillion parameters. You’re not running that on a Mac Mini.

The gap between “what you can run locally” and “what the cloud APIs offer” is widening, not shrinking. And every price increase on hardware makes that gap wider.

What Altman is actually saying

Strip the PR language away and his position is simple: DRAM should be allocated to whoever extracts the most economic value per gigabyte, and that’s data centers.

That’s not a tech argument. That’s a resource allocation argument. And it only works if you believe the entity running the data center is acting in your interest.

OpenAI is about to share ChatGPT and Codex under one usage cap starting December. They cut their funding round from $30B to $20B. There’s a claim on Hacker News with 588 upvotes that Claude Code re-sends background agent transcripts to the model, burning 15 to 20% of your tokens as overhead you can’t see or control. Kimi had a quota disaster and had to apologize and restore accounts.

These are the people Altman thinks should hold the DRAM instead of you.

Where this actually lands

The honest answer is that both sides are partly right and mostly talking past each other.

Local is too expensive for most people. A $22k Mac Studio is not a real option for 99% of developers and small teams. And maintaining a local setup is a real time cost. OpenClaw shipped 4 builds in 4 days this week. vLLM dropped a CUDA version. Jan had a security release. Ollama had two updates. If you’re self-hosting all of this, that’s hours of your week gone before you’ve done any actual work.

But “just use the API” isn’t free either. Quotas are shrinking. Costs are opaque. Token overhead from the tools you’re running on top of the API eats into your budget in ways you can’t measure. And every month there’s a new breach, leak, or supply-chain attack that reminds you what “someone else’s computer” actually means.

The middle ground is where most people are going to end up, whether they like it or not. Run small models locally for sensitive stuff. Use hosted APIs for heavy lifting. Use managed platforms for the infrastructure you don’t want to maintain. Pick based on what the data is, not on ideology.

Altman’s quote is going to age badly not because he’s wrong about the economics but because he’s wrong about trust. The local AI community isn’t fighting over DRAM allocation. They’re fighting for the right to run their own stack without asking permission.

That fight doesn’t end because RAM gets expensive. It gets louder.

What’s your setup looking like right now? Full local, full cloud, or somewhere in between? Curious how people are handling the cost squeeze without giving up control.


r/better_claw • • 14d ago

It’s a terrible use of the world’s limited RAM supply to have it sitting in personal computers, where it might only be used 5% of the time.

Post image
8 Upvotes

The OpenAI CEO recently said it’s a terrible use of the world’s limited RAM supply to have it sitting in personal computers, where it might only be used 5% of the time.

He argues that RAM would be better utilized in cloud data centers, especially as the AI boom continues to drive up demand and prices.

Apparently, even the RAM in your laptop has a greater purpose now.


r/better_claw • • 14d ago

They promised me Jarvis… they gave me Drew Barrymore in 50 First Dates. I will set off all your BS trip wires, but you should still try my Hermes alternative anyway. I make no money at all from it and it’s S tier good.

9 Upvotes

Let me get the dodgy stuff out first.

I'm not a developer. I can't even type a function that sums two numbers. I'm a simple dude from Rome (Italy) who's decent at systems thinking, and Claude wrote the code. There are thousands of delulu people on Reddit with my same lack of skills confidently saying they built something amazing. They didn't. Their slop is painful and follows the same security practices as a heroin addict who forgot to buy new needles.

I built this because I was fed up with agents forgetting stuff.

Even the best memory systems rely mostly on retrieval. That's fine if you don't expect the agent to connect dots on its own. But, as Donald Rumsfeld would say, the agent "doesn't know what it doesn't know". Which is doubly troubling. Both for agent performance and for the fact that smart people used to be Secretary of Defense.

To know what you don't know, you need to know something that hints at what you don't know.

If that sentence didn't 404 your grey matter, you get the architecture.

Instead of a .md file with facts appended on the go, Briglia spends up to 50k context tokens on a curated chronological history of its conversation with you.

Think about it. A full day of work with an agent can burn millions of tokens, but what you and the agent actually said to each other could be just 10k. Those messages are already an amazing distillation of everything you worked on. Every decision, every preference, every "no, not like that" is in there. Compact those 10k into a dense 1k summary and you've kept basically the whole day.

Briglia orders these summaries chronologically and keeps curating them. Recent weeks stay detailed and older months get compressed, but the model always sees the full picture, up to a year back. On top of that, a fact-archival pass catches what gets diluted over time, and it can grep the exact old messages when it needs a detail.

There are no sessions. It's one conversation, for months.

The result is a slightly bigger context, but way fewer tool calls to reconstruct what the hell you're talking about. Six months ago that would have meant context rot. Today's models handle 100k-250k just fine.

I have “biased” receipts of how good it is, it’s not just vibes. On my preliminary long-conversation memory benchmark it remembered 43 of 48 old facts on a month long conversation. Hermes + Hindsight got 39, Codex got 6. Method and data are explained on a link in the comments (yes, it's my own benchmark so it’s probably worth just slightly more than toilet paper to you - also, It’s a very preliminary version of the benchmark).

Install command and repo in the comments.

You need an OpenRouter API key and a Telegram bot token. That's it.

Fair warning, it's a real agent with full access to your machine (shell, files, web, email). Run it on a computer you trust it with.


r/better_claw • • 19d ago

Pi vs Hermes vs OpenCode for coding: I tracked the token cost of the same tasks across all three

63 Upvotes

I kept seeing people argue about which coding agent is “best” and realized most of the debate is vibes. Someone likes Pi, someone swears by Hermes, someone says OpenCode does the job fine. Very few people are comparing them on the same tasks with actual numbers.

So I did that. Same coding tasks, all three tools, tracked tokens and output quality over a few weeks.

This isn’t a general “which agent for which job” breakdown. This is specifically about coding. If you’re using any of these for code and wondering whether you’re leaving money or quality on the table, this is what I found.

The setup

I picked 5 task types I do regularly:

  1. Single function refactor (take messy code, clean it up)

  2. Bug debugging (here’s the error, find and fix it)

  3. Multi-file feature (build something that touches 4 to 8 files)

  4. Code review (read this PR, flag issues)

  5. Quick script generation (write me a bash/python script that does X)

Each task type got run 10 times across all three tools over a few weeks. Same prompts. Same codebases. I tracked input tokens, output tokens, number of back-and-forth exchanges to reach a usable result, and whether the first attempt was actually correct.

The raw numbers

Single function refactor:

  • Pi: avg 3,200 input tokens per turn, 1.8 exchanges to done

  • Hermes: avg 5,400 input tokens per turn, 2.1 exchanges to done

  • OpenCode: avg 2,800 input tokens per turn, 2.4 exchanges to done

Bug debugging:

  • Pi: avg 4,100 input tokens, 3.2 exchanges

  • Hermes: avg 6,800 input tokens, 3.8 exchanges

  • OpenCode: avg 3,400 input tokens, 4.6 exchanges

Multi-file feature:

  • Pi: avg 6,200 input tokens, 8.4 exchanges

  • Hermes: avg 9,100 input tokens, 9.7 exchanges

  • OpenCode: avg 5,100 input tokens, 14.2 exchanges

Code review:

  • Pi: avg 5,800 input tokens, 1.4 exchanges

  • Hermes: avg 8,200 input tokens, 1.6 exchanges

  • OpenCode: avg 4,900 input tokens, 1.8 exchanges

Quick script:

  • Pi: avg 2,100 input tokens, 1.1 exchanges

  • Hermes: avg 4,600 input tokens, 1.2 exchanges

  • OpenCode: avg 1,900 input tokens, 1.3 exchanges

Where the token gap comes from

Hermes loads more context every single turn. Memory files, skills metadata, agent personality config, channel bindings, conversation history with richer formatting. Even when you’re just asking it to fix a function, all of that rides along.

For a quick script, Hermes used roughly 2.4x the input tokens Pi used. Not because it wrote more code. Because it loaded 2,500 tokens of overhead before it even looked at your prompt.

Over a 3-hour coding session with maybe 40 exchanges, that overhead adds up to roughly 100K extra input tokens. Depending on which model you’re running, that’s real money for zero additional value on the coding task itself.

OpenCode goes the other direction. Lowest overhead per turn, but it needed more exchanges to get to the same result on anything complex. On multi-file features, OpenCode averaged 14.2 exchanges vs Pi’s 8.4. Those extra 6 rounds ate into the token savings from the lighter context. On simple tasks though, OpenCode’s efficiency held up because there weren’t enough rounds for the gap to compound.

Where quality actually differed

First-attempt accuracy (output was correct and usable without followup):

Single function refactor: Pi 78%, Hermes 72%, OpenCode 65%
Bug debugging: Pi 61%, Hermes 54%, OpenCode 41%
Multi-file feature: Pi 23%, Hermes 19%, OpenCode 11%
Code review: Pi 82%, Hermes 79%, OpenCode 71%
Quick script: Pi 89%, Hermes 85%, OpenCode 83%

Pi’s edge isn’t huge on any single task type, but it’s consistent. Across all 250 task runs (5 types x 10 runs x 5... no, 5 types x 10 each x 3 tools = 150 runs), Pi produced a usable first attempt more often than the other two in every category.

My read on why: Pi’s lighter context means the model spends more of its attention on your actual code and less on processing overhead that has nothing to do with the task. Hermes is smart enough to work around its own bloat most of the time, but “most of the time” means 5 to 10% more rounds spent recovering from context-distracted mistakes.

OpenCode’s lower accuracy on complex tasks comes from less sophisticated context management. It handles the code fine when everything fits in one window. Once you need it to reason across multiple files and remember architectural decisions from 8 exchanges ago, it starts losing threads.

The cost math for a real week

I estimated a typical coding week (not heavy, not light) at roughly:

  • 15 quick scripts or one-off fixes

  • 10 refactors

  • 8 debugging sessions

  • 3 multi-file features

  • 5 code reviews

Weekly token spend on coding tasks alone:

  • Pi: roughly 1.8M total tokens

  • Hermes: roughly 2.9M total tokens

  • OpenCode: roughly 2.1M total tokens (lower per-turn but more turns)

Hermes costs about 60% more than Pi for the same coding output. And that’s just the coding portion. If you’re also using Hermes for research and personal assistant tasks during the same sessions, the coding context gets mixed with everything else, which makes the overhead even worse because the model is now processing your morning briefing results alongside your Python traceback.

OpenCode lands in the middle on cost but at the bottom on complex task quality. It’s the cheapest per turn but the most expensive per completed task when the task is anything beyond a quick script.

What I actually do now

Pi for any coding session longer than 20 minutes. The token savings and higher first-attempt accuracy compound over a session. A 2-hour session on Pi vs Hermes saves roughly 30 to 40% on tokens and I spend less time on “no, I meant the other file” corrections.

OpenCode for quick one-off scripts and config generation. When the task is small enough that it won’t need more than 2 to 3 exchanges, OpenCode’s minimal overhead is a real advantage. It starts faster and costs less for these.

Hermes stays off my coding workflow entirely. I use it for everything else (research, automation, memory-dependent tasks, multi-channel). It’s great at those things specifically because of the features that make it expensive for coding. Memory, skills, multi-channel awareness. Those features earn their token cost when you’re doing agent work. They just don’t earn it when you’re debugging a null pointer.

The uncomfortable conclusion: the agent with the most features is the worst choice for the most common task developers actually do. Not because it can’t code. Because it carries the weight of everything it can do into every single turn, whether you need it or not.

What are your numbers looking like? Anyone else tracking token spend per tool or just going by feel?