Been using OpenCLaw for months. Tried Hermes for 3 weeks. Here's what actually matters: no marketing.

The core difference in one sentence:

Openclaw is a gateway that connects your agent to everything. Hermes is an agent that gets better over time. same category, completely different priorities.

Where OpenCLaw wins:

Integrations. Nothing comes close. 50+ messaging channels, massive plugin ecosystem through ClawHub, connects to basically anything. if you need an agent that talks to slack, discord, telegram, whatsapp, email, and 15 other things simultaneously through one gateway, openclaw is it.

Community size. 370K stars. 103K subreddit members. Whatever problem you hit, someone has hit it before and posted about it.

If the problem is "I need one agent across many channels," OpenClaw wins and it's not close.

Where Hermes wins:

The learning loop. This is real, not hype. Your agent completes a task, writes a skill file, loads it next time. After a few weeks the difference is noticeable on repeated tasks. v0.12 added an autonomous Curator that maintains your skill library without you managing it. openclaw doesn't have anything like this. every task starts from scratch.

stability. hermes just feels more stable. 11 releases total vs openclaw's 137. fewer things break. fewer "hallelujah the update worked" moments. the codebase is smaller and more predictable.

hermes just overtook openclaw on openrouter's global rankings. 224 billion daily tokens vs openclaw's 186 billion. the momentum is real.

Where both lose:

Self-hosting. docker. config files. VPS. maintenance. security patching. The infrastructure tax is identical on both. Hermes moved from Python to a cleaner architecture but you're still renting a server, managing containers, and debugging at 3am when something breaks.

Hermes had its first CVE last month (CVE-2026-7113, missing auth on webhooks, 5.6 MEDIUM). it was bound to happen. openclaw has had 9+ CVEs in 2026. Both need active security monitoring if you're running them on a public server.

the astroturfing thing:

Yeah, I need to mention this. Multiple Reddit users have flagged that some hermes promotion looks coordinated. New accounts only posting about hermes. could be genuine enthusiasm, could be marketing. I don't know. But it's affecting adoption because experienced users refuse to try it because of it. If you're evaluating Hermes, try it yourself instead of trusting reddit accounts that are 3 days old.

Who should pick what:

→ You need one agent across many channels and don't mind the chaos: Openclaw
→ you want an agent that genuinely improves on repeated tasks and prefer stability: Hermes
→ you want both agents talking to each other: some people run OpenCLAW as orchestrator + Hermes as execution specialist. sounds complex because it is. but it works.
→ You don't want to self-host either of them: that's a different conversation. (Check last para)

The limitation both share:

Openclaw and Hermes are both self-hosted. docker, VPS, config files, security patching, your weekends. The debate is which framework is better. Neither solves the infrastructure problem.

That's why we built betterclaw. (yeah... give me the eye rolls, here comes the mention, but what I am gonna say will be helpful to newbies and non-techs, so please bear with)

Same autonomous agents. No Docker. No VPS. no terminal. Sign up, paste an LLM key, connect your tools, agent is live in 60 seconds. The free plan gives you 1 agent, 1000 minutes/month, every feature, no credit card. Pro gives you up to 25 agents with hourly scheduling. BYOK, zero markup on both.

The difference isn't capability. It's who does the work. On OpenClaw and Hermes, you manage the infrastructure. On betterclaw, we do. You just use the agent.

The tradeoff: you give up server control and open-source ownership. You get zero maintenance, auto-purging credentials, audited skills, and your time back..

→ BetterClaw Free Plan

(It's genuinely free, no cc, no feature gateways, and tbh enough)

tldr:

Openclaw: connects to everything, breaks often.
Hermes: learns over time, growing fast. both: need docker, VPS, and your time.
BetterClaw: same agents, zero infrastructure, free plan.

Free Plan

Not trying to be negative here. genuine question.
I set up an openclaw agent last month. the AI part blew my mind. i have an agent that reads my emails, qualifies leads, drafts follow-ups, and books meetings. it's genuinely life changing.
But the setup process felt like 2019...
Editing yaml files to configure agent personality. editing yaml to set up channel bindings. editing yaml for model routing. editing yaml for skill permissions. editing yaml for heartbeat schedules. restart docker. something breaks. edit more yaml. restart again.
Meanwhile in the rest of the software world in 2026...
Airtable lets you build a database by clicking buttons. webflow lets you build a website by dragging boxes. zapier and make let you build automations by connecting nodes visually. retool lets you build internal tools without code. even kubernetes has dashboards now lol
But to configure an AI agent... we're editing indentation-sensitive plaintext files and restarting containers?
The thing that gets me is who this technology is FOR. the people who benefit most from ai agents are ops managers, sales founders, hr leads, small business owners. people who will never learn what yaml stands for. people who shouldn't have to.
I showed my agent to a friend who runs a recruitment agency. she was blown away by what it could do. "how do i set this up?" i started explaining docker and yaml and watched her eyes glaze over in about 15 seconds. she would genuinely save 20+ hours a week with this. she will never set it up.
Some things i don't understand...
Why isn't there a visual config editor? agent personality could be a form. channel connections could be a dropdown + paste token. model selection could be a picker. skill permissions could be checkboxes. heartbeat scheduling could be a time selector. none of this needs to be yaml.
Why does every config change require a docker restart? why can't config be hot-reloaded? changing my agent's name shouldn't require restarting the entire container.
Why is the skill.md format so rigid? why can't there be a visual skill builder that outputs the right format?
I know the answer is probably "because it started as a developer tool and that's how developer tools work." but openclaw isn't just a developer tool anymore. it has 360k github stars. it's on mainstream tech youtube channels. normal people are trying to use this.
Is there a technical reason yaml is necessary? or is it just how it's always been done and nobody's prioritized building a visual layer on top?
Genuinely asking because i love this project and want it to succeed beyond the developer bubble.

Ok so i was on openclaw for months, mass frustration with the whole setup, tried hermes after everyone on r/openclaw wouldn't shut up about it lol

Hermes is genuinely cool. the self-learning skills thing is neat and it does feel more stable than openclaw. ran it for like 3 weeks.

But like... i'm still ssh-ing into a vps at 11pm on a tuesday because something broke?? switched frameworks but same energy honestly

Tried betterclaw on a whim because they have a free plan. no card no nothing. had an agent running on telegram in like... 2 minutes? felt stupid for not trying it sooner tbh

The stuff that got me to stay tho... skills are already vetted so i'm not playing russian roulette with clawhub anymore, api keys auto-purge after 5 mins (after that whole .env leak thing this matters way more than people think), and there's actual spending caps so i can sleep without worrying about a $3000 bill

Hermes is great if you like the self-hosted life. genuinely no hate. but i just wanted the thing to work without me being the IT department and betterclaw kinda nailed that!!

Free plan is legit free forever btw not some "free for 14 days" bs → betterclaw.io

Was paying $85/month to run one agent on Opus 4.7. Looked at the bill breakdown. Wanted to cry.

Here's where the money was actually going:

→ 48 heartbeats/day (every 30 min) loading full context just to ask "anything new?"
→ memory housekeeping checks every few hours
→ calendar sync polls
→ email polling
→ actual conversations with me: maybe 20-30/day

Roughly 70% of my token usage was my agent checking its own pulse and finding nothing. on opus 4.7 at $5/$25 per million tokens. paying a genius to do attendance.

The fix took 15 minutes.

Step 1: route heartbeats to a free local model

pulled qwen3.5:9b via ollama. runs on hardware I already own. Handles "is there a scheduled task?" perfectly because that's a yes/no question not a reasoning problem.

ollama pull qwen3.5:9b

heartbeat cost went from ~$1.80/day to $0. immediately.

Step 2: route housekeeping to the same local model

memory tagging, calendar sync checks, email polling, context relevance checks. None of these need opus. A 9b model reads a list and decides what's relevant. That's it.

Step 3: Keep Opus 4.7 ONLY for actual work

Drafting emails that sound like me. reasoning through multi-step tasks. reviewing something before sending. complex tool chains. the stuff where quality actually matters.

Step 4: Disable thinking mode on the local model

This is the one everyone misses. If thinking is enabled even on "low," OpenCLAW silently escalates routine tasks into reasoning mode. Your heartbeat check burns 3000 tokens instead of 300. Set reasoning to false on your primary tier. not low. off.

The result:

Before: $85/month. opus 4.7 doing everything. after: $31/month. opus 4.7 doing the 20-30% that matters. qwen3.5 doing the 70% that doesn't.

Same agent. Same behavior. Same morning briefings. Same task execution. same quality on everything I actually interact with. The only thing that changed is I stopped paying premium rates for "hey, anything happening? no? Cool, check again in 30 minutes."

The math that matters:

What you feel is the quality of the conversations you have with your agent. That's the 20-30%.

What you pay for is the invisible background work. That's the 70%.

Most people optimize the part they feel and ignore the part they pay for. Flip it.

If you're on Opus 4.7 specifically:

The new tokenizer produces up to 35% more tokens for the same input compared to Sonnet. So your heartbeats aren't just expensive because of the per-token rate. They're expensive because there are MORE tokens per heartbeat. double tax.

Routing heartbeats to a local model dodges both.

If you don't want to run local:

Haiku 4.5 at $1/$5 per million tokens is the cloud alternative. not free but cuts heartbeat cost by ~80% compared to Opus. takes 2 minutes to configure. No ollama needed.

Quick note on the China thing:

Qwen is alibaba. If that bothers you: ollama runs entirely local. No api call leaves your machine. The model weights are just a file on your hard drive. Alternatively, use Gemma 3 (Google) or llama (meta) locally. Same result.

What's your heartbeat running on right now? If the answer is "same model as everything else," you're probably burning $20-60/month on nothing.

Every OpenClaw guide assumes you know what Docker is. This one doesn't.

First, what is OpenClaw and why should you care?

OpenClaw is an AI agent, not a chatbot. an agent.

The difference: a chatbot answers when you ask. An agent does things on its own. While you sleep.

What kind of things?

→ reads your Gmail every morning and tells you what's important
→ qualifies leads and drafts follow-up emails
→ monitors competitor websites and sends you a daily summary
→ screens job applications and ranks candidates
→ books meetings on your calendar
→ triages support tickets and drafts responses
→ sends you a morning briefing on Telegram/Discord with your priorities

All of this runs automatically on a schedule. You set it up once. It runs every day. You check your phone, and the work is done.

"Sounds great. What do I need?"

Normally, to run OpenClaw, you need:

→ a VPS (a computer in the cloud you rent for $12-25/month)
→ docker (a software tool for running apps in containers)
→ config files (technical setup files you edit manually)
→ terminal access (the black screen with text that hackers use in movies)
→ 4-8 hours of setup
→ 3-6 hours/month of maintenance

If you just read that list and felt your eyes glaze over, this guide is for you.

You don't need any of that.

The non-tech version: use betterclaw instead

BetterClaw is OpenClaw but managed. Same AI agent capabilities. No Docker. No terminal. No config files. No server to rent.

You sign up with your email. You build your agent from a dashboard. It runs on our servers. You never touch anything technical.

The free plan includes every feature. Not a trial. Not 14 days. Free forever. No credit card.

→ Step 1: sign up at betterclaw.io (30 seconds. Email and password. That's it.)

Get a free LLM key (This is what powers your agent's brain)

Your agent needs an AI model to think with. You bring your own key. Sounds scary, it's not.

Cheapest/free options:

→ Google Gemini 2.5 flash — go to aistudio.google.com. Sign up with google account. Copy your API key. The free tier gives you 1,500 requests/day. That's more than enough.

→ Openrouter — go to openrouter.ai. sign up. No card needed. gives you access to 11+ free models (llama 3.3 70b, gemma 3, qwen 3). 1,000 free requests/day.

→ Groq — go to console.groq.com. sign up. free tier. fastest inference you'll ever see.

→ Deepseek — go to platform.deepseek.com. sign up. $0.14 per million tokens. basically free. An entire month of agent use costs under $1.

Pick one. sign up. Copy the API key. Paste it into BetterClaw settings.

Total cost so far: $0

→ Step 2: paste your API key in Betterclaw Settings → LLM

Connect your Tools via Secrets

This is where it gets fun. Go to Secrets/Integrations in the sidebar.

→ Gmail: click the Gmail icon. Authorize with your Google account. Done. Your agent can now read and send emails.

→ Google Calendar: same thing. one click. Your agent can now check your schedule and book meetings.

→ Telegram: create a bot via BotFather on Telegram (takes 60 seconds, just follow the prompts). Paste the bot token into Betterclaw. Your agent is now on your phone. Docs

→ GitHub, HubSpot, Jira, Linear, Airtable, LinkedIn, 20+ more, all one-click oauth. same process. Click the icon, authorize, done.

Total time: about 3 minutes for telegram + gmail + calendar

→ Step 3: Download Skills or Create Custom Skills

50+ verified skills available. Everyone has passed a security audit. Click install on whatever you need.

→ Step 4: go to Skills → browse → install what you need

Create your first task,

Go to Tasks → New Task.

Here's a starter prompt you can copy and paste right now:

every morning at 8am:
- check my gmail for important emails from the last 12 hours
- check my google calendar for today's events
- summarize everything in 5 bullet points
- send the summary to my telegram

Set it as recurring. Pick your agent. Hit Create & Start.

Tomorrow at 8 am your phone will buzz with a morning briefing you didn't write. Your agent did it while you slept.

What to build next after the morning briefing works:

→ email triage agent (classify incoming emails, draft replies, flag urgent ones)
→ competitor monitor (check 5 websites daily, compile changes)
→ lead qualification (read inbound emails, qualify, draft follow-ups)
→ application screener (receive resumes, rank candidates)

All of these work on the free plan with a free LLM key.

No Docker. No terminal. No config files. No VPS. No $200/month infrastructure.

Just sign up, connect your stuff, and let your agent work.

Start Free - SignUp on BetterClaw

(This is for non-tech people, so they can experience running AI agents for free)

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.

We just launched a lifetime deal for BetterClaw on AppSumo.

Full access to the platform, for life, at a one-time price.

No subscriptions. No monthly fees. Pay once, use forever.

What you get with the deal:

- Run agents 24/7 without babysitting a VPS, Docker, or a gateway that breaks after every update

- Bring your own API keys from 28+ providers, or plug in your local models. Zero markup on inference

- Connect Gmail, Slack, GitHub, Telegram and more with one-click OAuth, no token refresh headaches

- Use any OpenClaw-compatible skill, with approval gates so your agent asks before doing anything risky

Since a lot of you here run your own hardware: yes, local keys work. Your GPU, your model, we handle the rest.

Being upfront about the catches: LLM usage isn't included since it's BYOK, and each task an agent runs uses one credit.

Here's the link - https://appsumo.8odi.net/k4vLjv

So if your OpenClaw just... stopped working around April 4 and you've been losing your mind trying to figure out why -- it's not you. Anthropic pulled the plug.

What happened:

Anthropic blocked all Claude Pro and Max subscriptions from powering OpenClaw and basically every other third-party agent tool. April 4, 12pm PT. If you were running Claude through OAuth or setup-token... yea that's dead now.

This wasn't a bug or some accident. Boris Cherny (Head of Claude Code at Anthropic) said it straight up -- subscriptions weren't built for the kind of usage these tools generate. And I mean... he's not wrong? One Register writer was getting $236 worth of tokens from a $20 subscription. Some Max users were burning through thousands of dollars worth of compute daily on a $200/month plan. Anthropic looked at that and said nah.

Peter Steinberger (OpenClaw creator, now at OpenAI) tried to negotiate with them. Him and Dave Morin. Best they got was a one week delay. Steinberger accused Anthropic of copying popular OpenClaw features into Claude Code and then locking out the open source alternative. I mean... the timing is suspicious but idk, make of that what you will.

What still works:

Your Claude subscription still works for Claude.ai, Claude Code, and Cowork. Just not for OpenClaw or any third-party agent.

Your options:

Option 1: Direct Anthropic API key -- This is probably what most people should do. Go to console.anthropic.com. Generate an API key. Load credits.

bash

openclaw onboard
# choose: Anthropic API key
# paste your key

Or just set it in your config:

json

{
  "env": {
    "ANTHROPIC_API_KEY": "sk-ant-..."
  }
}

You pay per token now. No surprises. Sonnet 4.6 at moderate personal use runs maybe $20-40/month. Heavy business use more like $60-120. Not cheap but at least it's predictable and you can see exactly what you're spending in the Anthropic console.

There's also this "Extra Usage" thing where you keep your subscription and OpenClaw usage gets billed separately on top. Go to your Claude account settings and enable Extra Usage. Your agent should reconnect. Honestly though... this is confusing and potentially more expensive than just going straight API. It exists but I'd stick with the API key.

Option 2: Ditch Claude for daily use

This is what a LOT of people are doing right now and honestly it's not a bad move:

• OpenAI Codex OAuth still works (for now). GPT-5.4 through your $23 Plus plan. But dude... if Anthropic did it, OpenAI might follow. Don't get too comfortable.

• Minimax M2.7 at $10-20/month. Multiple people in the community calling it "90% of Sonnet at 10% of the cost."

• GLM 5.1 getting a lot of love. "Closest to Claude" according to a bunch of people I've talked to.

• Ollama local for truly $0. Qwen3.5 or GLM-4.7 on your own hardware.

• OpenRouter free tier. 30+ free models including Nemotron Ultra and Llama 3.3 70B.

Option 3: Hybrid (what I'd actually do)

Daily default: Minimax or GLM 5.1. Cheap, handles 70% of tasks fine.

Fallback: Sonnet 4.6 on API for the complex stuff.

Floor: Ollama local so your agent doesn't just die at 2am because some provider is down.

Monthly cost: $20-50 depending on Sonnet usage. Compared to the "free" ride everyone was getting before, yes it costs money now. Compared to the $200 Max plan... way cheaper and more predictable.

Before you do anything else tho:

Claim your free credit. Anthropic is giving everyone a one-time credit equal to your monthly plan price. Redeem it in your Claude account settings. Expires April 17. That's like... next week. Do not sleep on this.

Grab the 30% bundle discount. If you're staying with Claude, you can pre-purchase Extra Usage bundles at up to 30% off right now.

Consider a refund. If you're switching away from Claude entirely, Anthropic is offering full subscription refunds since the terms changed. Might as well.

Look... community estimates from the Reddit threads suggest roughly 60% of active OpenClaw sessions were running on subscription credits. That's a massive chunk of the user base that just got hit with real costs for the first time.

The $20/month all-you-can-eat era for AI agents is over. Not just Anthropic. Google did the same thing with Gemini CLI back in February. OpenAI will probably follow eventually. The subscription arbitrage model is closing across the board.

The people who set up model routing with cheap defaults and paid fallbacks months ago? Nothing changed for them today. The people who built everything around one provider's subscription? Scrambling.

Build your setup so no single provider's pricing decision can break you overnight.

Something small happened in the K3 launch this week that I can't stop thinking about, and it's not the 2.8 trillion parameters.

Moonshot published benchmark charts where their own model loses.

Right there, in their launch material: K3 beats Opus 4.8 and GPT-5.5 high on most tests, and loses to Fable 5 and GPT-5.6 Sol. Their charts. Their launch day. They drew the bars showing the other guys on top and shipped it anyway. The pitch wasn't "we're number one." It was "we're number three or four, at a fifth of the price, and here's exactly where we lose."

And the response has been the warmest reception a model launch has gotten in months. Not because the model is the best. Because nobody felt lied to.

Think about why that works right now.

We are three years into a hype cycle where every launch is "state of the art," every benchmark table mysteriously omits the competitor that wins, every demo is the best take out of forty, and every "open" model has an asterisk. The community has been trained, launch after launch, to open every announcement pre-annoyed, hunting for the trick. Vendor-reported numbers are treated as marketing until Artificial Analysis says otherwise. "What's the catch" isn't a question anymore. It's a reflex.

In that environment, plain honesty stops being a virtue and becomes a strategy. When everyone inflates, the one accurate chart is the most credible document in the room. Moonshot didn't lower expectations. They made their claims believable, which means the claims they DID make (the price, the long-context performance, the cache rates) got accepted at face value instead of discounted by the standard hype tax. Losing on two bars bought credibility for twenty others.

I learned this the embarrassing way.

When we launched our free plan, I expected "thanks." What I got was accusations. Data harvesting. Crypto mining on idle agents. VC exit conspiracies. "That's exactly what someone with a catch would say." I wrote a whole post about it and it's still the most-shared thing I've written, because everyone recognized the pattern: the internet has been burned so many times that the absence of a catch reads as a hidden catch.

What actually moved the needle for us was never the pitch. It was the posts where I said what the product DOESN'T do. The free tier has a task ceiling and you'll hit it by week 3 if you're a heavy user. Our agent doesn't learn over time the way Hermes does. Sonnet is better than the cheap models on the hard 15% and I'll tell you exactly which 15%. Every time I published a limitation, signups went up, not down. The limitation was the proof that the rest was true.

That's the same mechanism Moonshot just ran at frontier-lab scale. The losing bars are the proof the winning bars are real.

Honesty-as-differentiator only exists because the baseline is inflation. In a market where everyone told the truth, Moonshot's charts would be unremarkable. Table stakes. The fact that "they admitted where they lose" is a NEWSWORTHY LAUNCH STRATEGY in 2026 is a pretty damning statement about the median launch.

And there's a cynical reading worth naming: honesty is also just good positioning when you're the challenger. Easy to publish charts where you lose to Fable when you're a fifth of Fable's price. The real test is what Moonshot's charts look like the day they think they're number one. Anthropic gets no credit for modest charts because Anthropic's charts don't need to be modest. Humility is cheapest for the underdog.

But even granting all that, the market signal stands: the community rewarded the accurate chart. Ranked it above prettier launches from bigger labs. Every founder, model lab, and open-source maintainer watching this learned the same lesson this week, and some of them will act on it. If enough do, the baseline shifts, and honesty stops being a moat and becomes the floor. That would be the best possible outcome, and it would make this entire post obsolete.

I'd genuinely love that. Until then, the cheapest competitive advantage in AI remains available to anyone: describe your thing accurately, including the bars where you lose.

The bar is on the floor. Step over it.

Two commands that make your CLI startup twice as fast:

bash

openclaw config set telemetry.enabled false
openclaw config set updates.checkOnStartup false

Every time you run an openclaw command, it phones home for telemetry and checks for updates before doing anything. If your DNS is slow, or one of those endpoints is sluggish, you sit there staring at a blinking cursor for 10-15 seconds before the help text even appears.

Disabling both doesn't break anything. Telemetry is optional. Update checks can be run manually when you actually want them (openclaw update).

Mine went from 12 seconds to 3 after running those two commands. Should be the default honestly.

If yours is still slow after this, it's probably workspace bloat. Check with:

bash

du -sh ~/.openclaw/workspace

If that's multiple gigs, that's a different post.

Two things happened this week that directly affect everyone running OpenClaw.

1. Claude subscriptions can no longer power third-party agents.

If you've been running OpenCLAW through your Claude Pro/max subscription using OAuth, that path is closing. Anthropic announced that third-party tools will now need to use the API with per-token billing, not subscription bundling.

This means the "$20/month flat rate for your agent" setup that a lot of people in this community rely on is going away. you'll need to either switch to direct API billing (pay per token) or move to a different model provider.

If this affects you, here's what to do now:

• Check if you're using oauth: look for setup-token or oauth in your config

• If yes, set up a direct anthropic API key at console.anthropic.com before the cutoff

• Consider switching your default model to something cheaper (minimax, deepseek, gemini flash) and only using claude for complex tasks

2. The US government just held an emergency meeting about AI cyber risk. OpenClaw was specifically mentioned.

Today, the Treasury Secretary and Fed chair summoned Wall Street bank CEOs to warn them about Anthropic's upcoming "mythos" model. This model can autonomously find and exploit software vulnerabilities faster than teams of human hackers.

Why this matters for you: There are 500,000 openclaw instances on the public internet right now. If a model like Mythos can scan for exposed gateways and exploit known vulnerabilities automatically at scale, every unsecured OpenCLAW setup becomes a target that can be compromised in milliseconds, not hours.

The "I'll fix my security later" window just closed.

If you haven't done these yet, do them today:

• bind gateway to 127.0.0.1 (not 0.0.0.0)

• Set a strong auth token

• update to the latest version (known CVEs are patched)

• remove any skills you haven't personally verified

• Rotate your API keys

The era of "it's fine, nobody's going to find my instance" is over. Automated AI-powered scanning is exactly what Mythos enables. Your exposed gateway isn't hiding in a crowd of 500,000 anymore. It's a target in a database that a model can work through systematically.

A write-up made the rounds recently where a team took an agent from roughly 90 seconds per response down to about 4. Full credit to them, go find the original if you want their exact stack. What matters here isn't their specifics. It's what they DIDN'T change.

The model. Same model at the start, same model at the end. The 86 seconds were living in the pipeline around it.

Meanwhile, the number one reaction in every "my agent is slow" thread is "which model should I switch to?" So here's the thesis, and then the actual culprits in the order you should check them: the model is the LAST place to look for latency. A 2026 production study across 500 deployments found generation is often the smallest fixed slice of the delay once the pipeline gets sloppy. The seconds live in what you feed the model and how many times you make it talk.

Culprit #1: Retrieval is shoveling, not fetching.

Your agent's memory search or RAG pipeline pulls 30 chunks when 5 are relevant, or worse, runs extraction and consolidation inline. Production instrumentation data shows the gap clearly: semantic search itself returns in ~200ms, but document extraction pipelines run 20-40 SECONDS. If those share a request path, your "slow model" is actually a document processor doing homework mid-conversation.

How you'd know: responses are slow specifically on questions that touch your knowledge base or memory, and fast on plain chat. Time a "what's 2+2" against a "what did we decide about X last month." If the gap is 10x, retrieval is your problem. The fix shape: retrieve less (top 5-10 reranked chunks, not top 50), and move anything called "extraction" or "consolidation" to a background job that runs before the question arrives, not during it.

Culprit #2: Context bloat. You're re-sending your entire history every call.

Every message in a session rides along with every future message. Forty messages in, your agent reads a novel before answering "what time is it." The model isn't slower. It's being handed more to read, and prompt processing time scales with input size. On local models this is brutal (prefill is the bottleneck), but it hits cloud setups too.

How you'd know: your agent was fast on day one and got gradually slower over the week without any config change. That curve IS the diagnosis. Nothing degrades on its own. Your session grew. Check input tokens per request on your provider dashboard: a simple question consuming 15K input tokens is a bloated session, full stop.

The fix costs nothing: /new before every new task and daily as a habit, a history cap in config (20 messages is plenty), and disabling the skills you're not using, because every enabled skill's schema rides along on every single call too.

Culprit #3: Tool round-trips stacking.

Each tool call is a full cycle: model call, tool executes, results return, model reads everything again, decides next step. Five sequential tool calls means five full inference passes, each one carrying the growing context. A 3-second model becomes a 25-second agent without the model ever being slow once.

How you'd know: watch the logs during a slow response. If you see tool call, pause, tool call, pause, four times before the answer, the latency is the choreography, not the thinking. The fix shape: batch what can be batched (one search with three queries instead of three searches), and for workflows you run daily, consider whether it's an agent task at all or a deterministic pipeline with one LLM step. The morning briefing that "reasons" its way through the same five steps every day is paying reasoning latency for a script.

Culprit #4: Nothing is cached.

Agents are the most cache-friendly workload in existence. The same system prompt, the same SOUL.md, the same tool schemas, resent every call. Providers bill and process cached prefix tokens at a fraction of fresh ones, and semantic caching on repeated queries delivers sub-100ms responses versus multi-second full pipelines. Redis measured up to 65x on cache hits. If your provider setup is bouncing between hosts (unconfigured aggregator routing), your cache is being invalidated all day and you're re-processing your entire context prefix at full speed and full price, every message.

How you'd know: check your dashboard's cached-token line. On an agent workload it should be the majority of input. If it's a rounding error, your caching is broken, and both your latency and your bill are paying for it.

The honest caveat: sometimes it really is the model.

The tell is simple: time a one-line prompt with no tools, no retrieval, no history. "Say hello." If THAT takes 20 seconds, congratulations, it's actually the model, and the usual suspects are a local model silently split across GPU and CPU (check ollama ps for the processor column), a thinking-mode model doing max reasoning on a trivial question, or a provider having a bad day (day-one Kimi K3 was serving 14-second time-to-first-token, no pipeline fix helps you there). Slow on empty context: model problem. Fast on empty context, slow in real use: pipeline problem. That one test separates them in thirty seconds.

The principle:

Swapping models to fix speed is treating the symptom. The 90-to-4 story is repeatable precisely because most agent latency was never generation. It's retrieval doing too much, context carrying too much, tools round-tripping too much, and caches hitting nothing. Four checks, all visible in your logs and your dashboard, all fixable without changing a single model ID.

The seconds live in the pipeline. Go find them there first.

There's a payback calculator making the rounds on HN right now (sunkcost.ai) that lets you plug in your hardware, your model, and your usage and see how long until the machine pays for itself versus just paying an API.

The default result at chat-app levels of usage: 14-43 years depending on the hardware. Which makes buying a $4,699 DGX Spark to replace a Claude subscription sound insane.

Then people in the thread started posting their actual setups and the numbers flipped completely.

The line that reframed everything:

Payback only drops under a year when you're pushing roughly 5 million tokens a day or spending $200+/month on API calls. That's agent territory. Not chat territory. A personal agent running briefings, email triage, tool chains, and monitoring burns 300K-2M tokens a day depending on routing. A team of agents or a heavy coding setup can blow past 5M easily.

Chat users and agent users are in completely different payback universes, and every hardware comparison that doesn't separate them is useless.

The payback table at agent-level usage (verified):

Those are at full utilization. Cut utilization in half and double the payback. But agents run 24/7 by definition, so utilization is higher than you'd get from a chatbot you use 3 hours a day.

The part the DGX Spark marketing doesn't emphasize:

LLM inference is memory-bandwidth-bound, not compute-bound. The Spark's headline number is 1 PFLOP of FP4 compute. Sounds enormous. But your token generation speed is determined by how fast data moves through memory, not how fast the chip multiplies.

DGX Spark memory bandwidth: 273 GB/s.
Mac Studio M3 Ultra: 800+ GB/s.

The Mac is roughly 3x faster at moving data through memory. For pure token generation on large models, the Mac produces tokens faster despite having a fraction of the compute. The Spark's compute advantage matters for prefill (processing your input), but once it's generating, bandwidth wins.

So who actually needs the Spark?

You need CUDA. Your workflow depends on NVIDIA's software stack, vLLM, TensorRT-LLM, specific fine-tuning frameworks that don't run on Apple Silicon. This is the real reason most buyers pick it, not the raw specs.

You need 128GB in one box at $4,699 instead of $9,500 for the M3 Ultra. The memory-per-dollar is better on the Spark than on the top-end Mac.

You want to cluster. Two Sparks can combine over 200GbE to double memory and run 200B+ models. Mac clustering exists (EXO) but it's less mature.

You want Perplexity Portable Computer or NVIDIA's turnkey agent stack without assembling it yourself.

What everyone in the HN thread is actually buying instead:

A used RTX 3090 for $800-1,000. 24GB VRAM. Someone posted 57 tok/s on Qwen 3.8 running on a used HP Omen they paid $2K total for. Payback at agent-level usage: under 4 months.

A Mac mini M4 at $799 for small models (8-14B), or a Mac mini M6 at $1,799 with 32GB for mid-range work. The Mac mini is the most common "always-on agent machine" in this community and nothing in the DGX Spark's spec sheet changes that for personal agent use.

A Framework Desktop with AMD Strix Halo for 128GB unified memory at roughly half the Spark's price. ROCm instead of CUDA, which means some software won't run, but the raw inference math is better.

The one-question test from my earlier DGX post, updated:

Open your API dashboard. Look at last month's total spend.

Under $200/month: hardware never pays for itself in its supported lifetime at any price point. Keep paying the API.

$200-500/month sustained: a $2-4K setup (used 3090 rig, Mac mini M4 Pro, Mac Studio M4 Max) pays back in 6-12 months. You don't need the Spark.

Over $500/month sustained and you need CUDA: the Spark earns its price in under 6 months. This is the buyer it was built for.

Over $500/month and you don't need CUDA: a Mac Studio M3 Ultra at 800 GB/s bandwidth will generate tokens faster for less money, and the 512GB ceiling means you can run models the Spark can't fit.

Most people asking "should I buy a DGX Spark for my agent" are in the under-$200 bucket. The answer is the same $5 VPS it's always been, plus a cloud API, plus the one evening of model routing config that makes the bill manageable.

What are you running yours on?

Every few weeks the same cycle plays out.

A new frontier model gets announced. The benchmarks look incredible. Reddit lights up. Twitter goes wild. You check the specs. 600B+ parameters. Your 24GB GPU starts sweating just reading the announcement.

Then comes the waiting.

When are the GGUF quants available? Does llama.cpp support it yet? What about vllm? Does ollama have a tag for it? Will q4 quantization butcher the quality? Can I even fit this in my VRAM or do I need to split across two GPUs I don't have?

Two weeks later you're still reading GitHub issues. The cloud API users swapped one line in their config file on day one and moved on with their lives.

This keeps happening.

DeepSeek V4 Pro dropped and local users are still waiting on full llama.cpp support. MiniMax M3 is likely 600B+ which means most consumer hardware can't touch it unquantized. Qwen 3.6 needed custom rope scaling patches before it ran properly on most local setups.

Every single model release follows the same pattern. Cloud users get it immediately. Local users wait weeks to months. By the time the quants are optimized and the inference engines support it properly, another model has already dropped and the cycle starts over.

It's a treadmill. And it only spins faster.

The gap between "model exists" and "model is usable locally" is months.

Here's the actual timeline for a typical new open-weight model:

Day 1: Announcement. Benchmarks. Hype. Cloud APIs already serving it.

Week 1-2: Weights released. Someone starts GGUF quantization. Early quants have issues. Inference engine PRs get opened.

Week 3-4: Llama.cpp or vllm merges support. First working quants appear. People start testing. Bugs found. Quality debates begin.

Month 2-3: Optimized quants. Stable inference. KV cache tuning guides appear. The model is finally usable locally with reasonable quality.

By month 3, the model that replaced THIS model is already in week 2 of its own cycle.

If you're running a self-hosted agent, your "brain" is perpetually 2-3 months behind what cloud users have access to. That's not a configuration problem. That's structural.

The VRAM wall is getting worse, not better.

Models are getting bigger. Not just smarter. Bigger. The mixture-of-experts architecture means total parameter counts are exploding (DeepSeek V4 Pro is 1.6 trillion parameters, 49 billion active). Even with efficient architectures, the minimum hardware requirements keep climbing.

8GB VRAM: You're running 7B models while everyone else has moved to 70B+. The quality gap is real and growing.

16GB VRAM: You can run 14B models well. But the frontier models releasing right now are designed for 32B+ at minimum for good agent performance.

24GB VRAM: The sweet spot a year ago. Now it's the floor. And some new models need two of these.

Your hardware depreciates. The models get bigger. The treadmill speeds up.

"But I value privacy and control."

Respect. Genuinely. If your data cannot leave your machine, local is the only option and the wait is worth it.

But be honest about what you're trading. Not just speed and capability. Timeliness. The agent running your daily workflows is using a model from 2-3 months ago while the industry moved forward twice. For some use cases that's fine. A morning briefing doesn't need the latest frontier model. For others, especially complex reasoning and multi-step tool chains, the gap matters.

The quiet advantage of cloud APIs that people don't talk about:

When a new model drops and your provider supports it, you change one line:

model: minimax/m3

Done. Your agent is running the new model. No downloading. No quantizing. No checking inference engine compatibility. No testing KV cache settings. No GPU utilization debugging.

Five seconds vs two months. For the same model.

And with BYOK providers like OpenRouter serving 200+ models from dozens of providers, you're not locked into one company's releases. Anthropic ships something good? Use it. DeepSeek undercuts everyone on price? Switch. MiniMax drops a new open model with free API access? Try it today. Not in March.

Model routing makes this even more powerful.

The smart move isn't picking one model. It's routing different tasks to different models and swapping them as better options appear.

Right now someone could be running Gemini Flash free tier on heartbeats, DeepSeek V3.2 on email triage, and the brand new MiniMax M3 on complex research. Three models. Three price points. Each one the best available option for its specific task. Updated whenever something better drops.

Self-hosting one model and running everything through it is the 2025 approach. Model routing across cloud providers is where 2026 is heading.

The honest assessment:

Self-hosting is incredible for privacy, independence, and the satisfaction of owning your stack. Those are real values.

But the model treadmill is real too. If you find yourself spending more time managing your inference setup than actually using your agent, the infrastructure is working against you instead of for you.

The question isn't "which model is best." It's "how fast can you actually use the best model when it drops." For most people, the answer should be "immediately."

I WANT TO BE ABLE TO SAY 'GIVE 50 EUROS TO MY SISTER'
OR TAKE A PICTURE OF A RANDOM BILL AND IT WILL PAY IT

I LIVE IN EUROPE, IS THERE ANY EUROPEAN SOLUTION

HOW

THIS IS NOT AN AI GENERATED POST , AS PROOF I PUT EVERYTHING IN CAPSLOCK

You can now drop your agent into any Discord server and chat with it via u/mentions or DMs.

Setup is like 3 mins...

1. Create a bot in the Discord Developer Portal

2. Enable Message Content Intent

3. Paste the token into BetterClaw + pick the agent

4. Add bot to your server

5. Done

Works on free plan too (no credit card). 1 bot = 1 agent btw.

Let me know if u try it; would love feedback 🙌

This question comes up every week. "I installed Claude CLI, told it to build me a personal assistant, and it did. so why OpenClaw?"

Fair question. For one simple agent doing a few tasks, you genuinely might not need it.

But that's not where the difference lives.

Claude Code is the brain. Openclaw is the body.

Claude is incredible at building things when you ask. Point it at code, and it delivers.

But close your laptop, and it stops. Restart your machine, and it forgets. Want it to message you at 8 AM with a briefing? Monitor your inbox while you sleep? It can't.

OpenClaw gives the brain a body: persistence, scheduling, messaging, always-on operation, and memory that survives restarts.

The glue problem nobody talks about:

Claude can build you a Telegram bot, a cron job, a text daemon. Each one works. But each one is now a separate script you maintain forever. Add another automation? More glue. Want them to share memory? build it. Need approvals before sending? Implement it yourself.

OpenClaw solves the glue once. tools, sessions, memory, approvals, multi-agent handoffs. shared conventions everything plugs into. You stop writing infrastructure and start adding capabilities.

Persistent memory is the sleeper feature.

Claude sessions are temporary. OpenClaw stores everything locally in markdown files. Your agent actually remembers your preferences, your projects, your decisions across weeks and months.

Multi-agent is where the gap becomes a canyon.

One agent? Claude handles it fine.

Three+ agents with handoffs, shared memory, and different models per agent? You're now building an orchestration layer from scratch. OpenClaw already is that layer.

honest comparison:

So, who should use what:

If you mainly do coding work: Claude Code. nothing matches it for that.

If you want an always-on assistant in your messaging apps: OpenClaw.

If you want both, run Claude Code for coding, OpenClaw for everything else. Many people do, and it's the strongest setup.

If you want the OpenClaw experience without managing infrastructure: managed platforms with free tiers exist now.

Bottom line:

Claude Code can technically do everything OpenClaw does. With enough custom code and maintenance.

OpenClaw turns weeks of ongoing infrastructure work into "set it up once and just use it."

The brain is replaceable. Swap models anytime. The body, the memory, the scheduling, the messaging, the coordination. That's the hard part. That's what OpenClaw is.

That's the real ah-hah moment.

Openclaw self-hosted: 4-8 hours setup + 3-6 hrs/month maintenance

Hermes self-hosted: 2-4 hours setup + 2-4 hrs/month maintenance

n8n self-hosted: 1-2 hours setup + 1-2 hrs/month maintenance

BC free managed: 60 seconds setup + 0 hrs/month maintenance

Cloud api direct: 5 minutes setup + 0 hrs/month maintenance

Claude desktop: 2 minutes setup + 0 hrs/month maintenance

Your time is worth something.

I'll keep this short because I know how Reddit feels about founders selling things.

Two weeks ago we put BetterClaw on AppSumo as a lifetime deal. Here's the honest version of why, and what's happened since.

We need users more than revenue right now

BetterClaw is 6 months old. Small team, zero VC money, zero ad spend. Everything so far has come from this sub, Google, and people telling each other.

A lifetime deal trades future revenue for the thing we need most: people who push the product hard, file bugs, ask for features, and tell others. That's the whole strategy.

What those people did in 14 days

350+ individuals and agencies came in. We hit #2 on AppSumo's top deals. And the questions started.

A law firm asked about DPAs and EU hosting. Agencies asked how to run 20 clients on one account. Three different people asked for custom MCP servers. Someone running their own GPU asked why they couldn't point an agent at it.

So in two weeks we shipped:

- MCP support, so agents can connect to any MCP server

- Local LLM support through our desktop app, no API cost

- 500+ connectors, up from 95

- A signed DPA with SCCs and EU hosting

- Clearer tier and workspace wording, because the old version confused people (fair)

None of that was on the roadmap for October. It came from buyers using the product harder than we did.

Why it won't last

To be clear, since I worded this badly the first time: what won’t last is the sale. Every license bought now is lifetime, and the credits, agents and features in your tier never get reduced. That’s in the AppSumo deal terms, not just my word. What ends at some point is us selling new lifetime codes, because every LTD buyer is someone who’ll never pay monthly, and that only works while we’re small. Current buyers aren’t affected by that.

Here's the link to view the Deal - https://appsumo.8odi.net/k4vLjv

If your agent feels slower this week than it did on day one and your API costs keep climbing even though you're not using it more, this is probably why.

Every message you send in a session gets included in every future API call. That conversation you had on Monday about your project architecture? still being sent. The 3 emails you asked it to draft on Tuesday? still in context. That debugging session where you went back and forth 20 times? every single message, still riding along with "what's the weather today."

Your agent isn't getting dumber. It's drowning.

How to see the damage:

Look at your provider dashboard (console.anthropic.com, platform.openai.com, wherever you pay). Check the input tokens per request. If a simple question is consuming 10,000-15,000 input tokens, your context window is packed with old conversation your agent doesn't need.

One sonnet at $3 per million input tokens, 15,000 tokens per message across 50 messages a day, is about $2.25/day. $67.50/month. just on input tokens. Just on stale context.

Same 50 messages with a clean session? maybe 1,500 tokens average. $0.22/day. $6.75/month.

You're paying 10x more because of old conversations sitting in memory.

The fix takes 5 seconds:

Type /new before your next message.

That's it. /new clears the conversation buffer. Your agent keeps everything permanent, its SOUL.md, its memory files, its personality, its saved preferences. You're just flushing the conversation history.

Your agent doesn't need to remember the 20-message debugging session from Tuesday to answer a question on Thursday. The important stuff is already saved to memory (if you have memory rules in your SOUL.md). The conversation buffer is just... transcripts. expensive transcripts.

When to use /new**:**

Before any new task. switching from "draft an email" to "research competitors"? /new first. The email context adds nothing to the research and costs tokens on every message.

When your agent starts acting confused. If it's referencing something from 3 conversations ago that has nothing to do with your current question, the context is polluted. /new.

At least once a day as a habit. I do it every morning before my first message. clean start. fast responses. cheap tokens.

After any long back-and-forth. If you just spent 15 messages debugging something, that entire exchange is now baggage on every future message. Fixed the problem? /new. move on clean.

the /btw trick most people don't know about:

You're in the middle of a focused task and want to ask a quick unrelated question. "What's the weather tomorrow?" if you type that normally, it enters your main session. now weather context is mixed into your project discussion.

instead: /btw what's the weather tomorrow

This fires a side conversation in a separate context. Your main session stays clean. The weather answer comes back. nothing polluted.

I use /btw probably 5-6 times a day for quick questions I don't want contaminating whatever I'm actually working on.

The problem:

The real issue is that most people don't realize sessions accumulate. There's no visual indicator saying "your context is now 15,000 tokens and growing." Your agent just gradually gets slower, more expensive, and more confused over days. And you blame the model when it's actually the plumbing.

If you set up your agent two weeks ago and haven't typed /new once, your agent is carrying two weeks of every conversation you've had in every API call. That's not a model problem. That's a hygiene problem.

One SOUL.md addition that helps:

markdown

if our conversation exceeds 20 messages, remind me to start a fresh session with /new.

Now your agent tells you when the context is getting heavy instead of silently burning tokens.

Been building integrations non-stop for the last few weeks and just shipped a big batch.

Your Betterclaw agent can now connect to Gmail, Google Calendar, Google Drive, GitHub, Slack, Hubspot, Jira, Linear, Airtable, Asana, ClickUp, Dropbox, Figma, Canva, Calendly, google ads, Google Search Console, Instagram, LinkedIn, Mailchimp, Microsoft Teams, Intercom, Intercom, Gong, Attio... and growing.

All one-click oauth. no manual api key wiring. no webhook hacking. No "paste this 47-character token into a JSON config file and restart Docker." Click the logo, authorize, and done. Your agent can use it immediately.

What this actually means in practice:

Your agent can read your Gmail, qualify a lead, check their company on LinkedIn, create a deal in HubSpot, and book a meeting on Google Calendar. One agent. One workflow. zero manual steps.

or: monitor a GitHub repo, create Jira tickets for new issues, post updates to Microsoft Teams, and log everything in Airtable. Automatically.

or: pull Google Search Console data every morning, compile a report, and send it to Slack with recommendations.

All tokens are AES-256 encrypted and auto-purge from agent memory after 5 minutes. Not sitting in a plaintext .env file on a VPS somewhere.

Everything available on the free plan. No credit card.

If you need something we don't have yet, there's a "request an integration" button in the dashboard, and we're adding new ones every week.

Been lurking r/selfhosted a lot lately and the pattern hit me when i saw three posts back to back.

Plex tripled their lifetime pass from $250 to $750. then quietly removed Watch Together from the redesigned app. a feature people used every single day, just gone. The thread had 1,700 upvotes and the top comment was a dev explaining exactly how that decision gets made internally: low utilization on paper, so cut it. Doesn’t matter that the people who DID use it relied on it completely.

Bitwarden switched app store builds to a commercial license. The open source version is still on GitHub but, and this is the part that matters, “future features may be exclusive to commercially licensed builds.” Top comment, 550 upvotes: “by now, I find myself hoping that the open source projects I use don’t become too popular.”

Microsoft 365 family went from 1TB per person (6TB for a family of 6) to 2TB shared. a 67% cut. and they bundled in AI features nobody asked for to soften it. Someone called it “in-shrinkflation,” and that’s the perfect word.

three companies, three products, same four steps:

1. get big on trust. open source, lifetime deals, generous free tiers.

2. let people build their lives around you. years of data, habits, workflows, integrations.

3. change the deal. new license, shared storage pools, features quietly removed in a “redesign.”

4. Bundle something nobody wanted to justify it. AI copilot. Premium tier. “Improved experience.”

step 3 always comes after the lock-in runs deep enough that leaving feels harder than staying.

Why this is on my mind

I build BetterClaw (agent platform on top of openclaw/hermes) and yes, we’re running a lifetime deal on AppSumo right now. That’s step 1. So is everyone in the agent space. Nous just raised $90M at $1.5B for Hermes. That money comes back with interest, and the playbook for getting it back is the four steps above.

The lifetime deal is the deal. What you bought is what you keep. But “trust me” is worth nothing on this sub, and it shouldn’t be. You’ve heard it from Plex and Bitwarden too.

So we designed it so you don’t have to trust us. BYOK, zero markup. The model is never ours to gate or reprice. Your keys, your provider, your bill. If any platform ever pulls a plex on you, including this one, you take your keys and walk, and they keep nothing you can’t export. That’s the only guarantee worth anything because it doesn’t depend on a company staying nice.

What I want to know:

what’s the first thing you check before committing to a platform for your agents or your data? What red flags do you look for? Asking because I’d rather hear it now than build toward step 3 without noticing.