r/openclaw

What do you people think of Google IO presentation of Google Spark and its broader integration with the Google ecosystem to challenge OpenClaw.

Personally, I don't think users care who provides the service as long as it makes their life easier. I'm not sure OpenClaw can compete with Google's distribution and ease of use long-term.

Requirements:

You spent over $1000 on (Opus) tokens for OpenClaw and have experience.

Snapchat.

---

Hopefully you can understand the benefits. DM me.

What do you guys think about it so far? Good? Bad?

Is it worth trying?

Is there a way to connect OC to my Google One sub? or is it API only through Ai studio?

The day after I installed openclaw I realized I was in over my head with the time commitment I’d need to even begin to master it. Per their policy I’ve reached out to the email address listed for a refund but it keeps bouncing back, no such address. Thanks for any suggestions!

This is mostly aimed at vibe coders who are unable to or don't want to guide agent every 10 minutes.

My two biggest questions are:

1. How do you actually make a coding agent keep working for at least 1 hour, ideally 8–20 hours without constantly telling it to continue?
2. What language/framework/architecture is actually agent-friendly for a local app that integrates many existing technologies and has a lot of real-time-ish flows?

The first question is the immediate practical one.

How on earth do people make these agents keep running?

Unless I write some script that watches the terminal and keeps sending:

«continue unless you are fully done; if you are fully done, say DONE as your last word»

or unless I build some server hook / automation loop around the agent, it just keeps stopping. It finishes when I do not want it to finish. It reports halfway through the plan. It asks for input when there is nothing useful for me to evaluate yet.

So I’m asking very practically: what are people doing right now to make agents actually work for long stretches?

The second question is about architecture.

I’m trying to figure out what kinds of architectures are actually good for AI-maintained local applications, especially systems that may eventually reach tens of thousands of lines and coordinate multiple local components/processes.

I thought an event-driven architecture might be good for this. I tried going in that direction with NATS-style communication. But my current impression is that agents are not good at it. Maybe I did something wrong, but it felt like the agent became terrible at reasoning about the system once everything was happening through events.

If the agent has to understand the system by reading event logs, tracing IDs, and reconstructing causality from a stream of messages, that feels like a bad fit. Maybe this is just not agent-friendly, at least not for a solo/vibe-coded local application.

So the deeper question is:

«What architecture makes an AI agent unusually good at maintaining and extending the project?»

Not what architecture is theoretically elegant. Not what architecture is optimal for a senior engineering team. What architecture is actually easiest for the model to reason about, test, debug, and extend?

The rough workflow I want is:

1. Put the model on extra-high thinking.
2. Give it a messy pile of project material: old specs, notes, partial repos, failed ideas, design thoughts, todos, architecture sketches, etc.
3. Make it spend serious effort organizing that into a usable knowledge base.
4. I review/correct that knowledge base.
5. Then make it spend serious effort writing the implementation plan.
6. I review/correct the plan.
7. Then make it execute for a long stretch in a sandbox without constantly stopping and asking me to say “continue.”

Roughly:

«1 hour knowledge organization
1 hour implementation planning
20 hours execution»

The exact numbers are not the point. The point is depth and continuity.

I do not want the model to spend 5 minutes writing a plan, 10 minutes coding, and then report “done.”

The first problem is messy context.

If I give an LLM a bunch of files, old specs, old ideas, and previous attempts, it often treats everything as if it was written today and is equally valid. But half the material may be obsolete, contradicted, abandoned, experimental, or from a failed attempt.

The model does not magically know the status of each piece of knowledge.

So I feel like there needs to be an explicit intermediate stage: not coding, not planning, but knowledge organization.

Something like:

- current requirement
- old requirement
- obsolete idea
- failed attempt
- unresolved question
- architectural constraint
- implementation detail
- still-useful note
- contradicted by later note
- needs user confirmation

Then I can correct the knowledge map before the model starts planning.

That seems much more useful than dumping 50 files into context and hoping the model “gets it.”

Is anyone using tools/workflows that actually do this well?

The second problem is shallow plan mode.

A lot of current “plan mode” workflows feel shallow. The model asks two or three questions, writes a short plan, and then acts like it has enough alignment.

But that is not what I want.

I want the model to actually spend real effort thinking through the system before writing code.

People always say some version of:

«5 minutes of planning saves an hour of work.»

Fine. Has anyone actually made that real with LLM coding agents?

Because right now a lot of agent planning feels like a formality. It asks a few questions, writes a plan, and then immediately wants to start coding. Or it keeps rewriting the whole plan over and over instead of thinking deeply first and then writing a stable plan.

Maybe the missing workflow is not just “plan mode.” Maybe it is something like:

«plan the planning → organize the knowledge → ask real questions → write the implementation plan → execute until the plan is actually complete»

The third problem is premature reporting.

This is probably my biggest issue.

The model writes an implementation plan. I review the implementation plan. Then it starts implementing. Then it stops halfway and reports back.

Why?

If I already reviewed the implementation plan, why does it need me to keep saying “continue implementing the plan”?

If it has not hit a fundamental blocker, if the plan has not become invalid, and if there is nothing genuinely useful for me to evaluate yet, why is it reporting at all?

A lot of completion reports are basically just the implementation plan rewritten in past tense:

«I added X.
I implemented Y.
I updated Z.»

That is not useful to me.

For a vibe coder, I do not want to inspect a pile of changed files. I do not want a past-tense summary of the plan. I do not want a fake checkpoint that exists only because the agent decided to stop.

What I want is one of these:

1. A working thing I can actually run.
2. A clear presentation layer that shows me something tangible.
3. Exact instructions for how to test it and what to look for.
4. A genuinely important question that changes the plan.
5. A real blocker that prevents progress.
6. Or, if none of those apply, just keep executing.

If the current work is still mostly mocks, scaffolding, internal wiring, or abstract architecture, then there may be nothing useful for me to evaluate yet.

In that case, why stop?

Why not finish the planned implementation first, then let me test and evaluate when there is actually something to evaluate?

Whose time is more precious: mine, or the agent’s?

I am not saying the agent should never stop. It should stop if:

- the plan is fundamentally wrong
- a major architectural decision is needed
- a blocker cannot be resolved
- it has something real and testable to show
- continuing would obviously waste a lot of work

But if it is just stopping because it completed “some steps,” that feels useless.

The fourth problem is making agents actually work for long stretches.

How are people actually spending their token budgets productively?

With some subscriptions and API setups, the amount of possible usage is huge. But in practice, I find it hard to spend it well because the agent keeps stopping, asking for input, or producing reports that do not help.

How do you make an agent execute for one hour, eight hours, or overnight?

Can you actually do this in a useful way right now?

Do you use scripts that automatically send continuation prompts? Do you use hooks? Do you run agents inside some kind of supervisor process? Do you use a specific tool that already solves this? Or is the answer simply that current agents cannot really do this yet without external automation?

I have tried or looked into OpenCode, OpenClaw, Gemini, Claude, Codex, Pi, and a bunch of Kanban-board-style workflows.

My current impression is that OpenCode with Docker sandboxes is one of the more practical setups. Terminal UIs feel more reliable to me than a lot of GUI agent setups, and Docker sandboxes feel like a decent practical compromise, especially on Windows if you do not want to deal with a full WSL workflow. Not saying WSL is bad, and obviously sandbox security is its own topic, but Docker sandboxes feel convenient.

I have not deeply tried the “agents roleplay an organization” style of workflow. Maybe I should before judging it. But from the outside, I worry that a lot of multi-agent setups become corporate roleplay: workers praising each other, moving cards around, doing shallow reviews, and spending my money on simulated middle management.

Is there a recommended setup that actually achieves the goal?

Not roleplay. Not card movement. Not fake review loops.

Actual useful long-running work.

The fifth problem is language/framework choice.

For AI-heavy coding, I’m starting to think one of the most important constraints is:

«Is the model actually good at working with this language, framework, and project structure?»

For normal engineering, you might pick something because it is technically optimal, elegant, fast, scalable, or theoretically clean.

But if the main implementer/maintainer is an LLM, model proficiency becomes a first-class constraint.

A boring, widely represented stack may beat a technically superior stack if the model is much better at writing, debugging, testing, and extending it.

This seems especially important for vibe coders. If the agent is eventually supposed to handle tens of thousands of lines, I care less about what is theoretically elegant and more about what the model can reliably modify without causing cascading breakage.

Are there good benchmarks or practical community knowledge on which languages/frameworks current models handle best?

The sixth problem is architecture.

I’m trying to figure out what kinds of architectures are actually good for AI-maintained local applications, especially systems that may eventually reach tens of thousands of lines and coordinate multiple local components/processes.

At first, it is tempting to optimize for extensibility:

- make everything swappable
- make everything modular
- make it easy to add new components
- make components communicate through clean boundaries

But I’m starting to think extensibility matters less than maintainability at the beginning.

The first priority is making the thing actually possible to reason about, test, repair, and expand without every change breaking ten other things.

So maybe the default should be:

- clear component boundaries
- explicit interfaces
- boring communication patterns
- deterministic tests where possible
- mocks at boundaries
- real pressure points represented in tests
- replace one mocked component at a time with a real component
- every component can be tested in isolation

Basically: make the architecture agent-legible before making it powerful.

A folder structure template is not enough. I’m more interested in reusable architecture templates where the component communication, boundaries, testing strategy, and failure modes are already thought through.

Do repos like this exist?

Not just:

«here is a folder layout»

but more like:

«here is a healthy skeleton for building a local multi-component application that an agent can keep extending without turning it into spaghetti»

The seventh problem is orchestration.

Do Kanban boards, orchestrator/worker setups, and multi-agent systems actually help with this?

A static task board seems limited because after task 3 is done, task 8 may no longer make sense. Someone has to re-evaluate the plan. The agent needs to manage its own work, not just move tasks from “todo” to “done.”

Maybe persistent sub-agents/workers would help. For example:

- one worker owns tests
- one worker owns architecture
- one worker owns a subsystem
- one worker owns documentation/knowledge state

But that can also become useless roleplay if it is not grounded in real artifacts.

Has anyone found a multi-agent workflow that actually works for this kind of long execution?

The eighth problem is whether my preferred approach is even optimal.

Maybe this workflow:

«organize sources → plan deeply → execute for a long stretch»

is worse than:

«run multiple worktrees/agents in parallel with different constraints → compare implementations → keep the best ideas»

That might be a better way to spend a large token budget.

But it also creates another problem: now I have to review multiple implementations, fix multiple broken versions enough to compare them, and give slightly different instructions to each branch.

Has anyone compared these approaches in practice?

1. One deep workflow that spends a lot of effort organizing knowledge, planning, and then executing for a long stretch.
2. Multiple parallel worktrees/agents generating competing implementations that you compare afterward.

Which one actually works better for non-trivial projects?

My questions:

1. How do you make coding agents keep working for 8–20 hours without constantly telling them to continue?
2. Are there tools/workflows that first organize a messy project knowledge base before planning?
3. Are there serious AI planning workflows that go deeper than current shallow “plan mode”?
4. How do you stop agents from reporting halfway through the plan unless there is something actually worth showing?
5. What languages/frameworks are currently most agent-friendly in practice?
6. What architectures are actually good for AI-maintained local applications with many flows/components?
7. Are event-driven/message-based architectures just a bad fit for AI-maintained projects, or am I using them wrong?
8. Are there reusable architecture templates that define healthy component communication, not just folder structure?
9. Is it better to run one deep workflow, or multiple parallel worktrees/agents and compare outputs?
10. What does your actual overnight or long-running AI coding workflow look like?

I am not asking for hype, future predictions, or emotional takes.

I’m asking this in the most practical way possible.

Maybe my framing is wrong. Maybe the real bottleneck is somewhere else. If so, criticize the premise.

I mostly want to know what people are actually doing right now that works.

Sorry for ai generating this, but I made sure to review it bunch of times.

trying to get realistic numbers here.

my use case is pretty basic: agent handles admin work like identifying relevant emails, sorting/prioritizing, drafting replies, and sending compliant cold outreach. Assume ~8 hours/day of work.

What are people actually PAYING per month for this?

Looking at APIs like:

• MiniMax
• Claude
• Gemini
• DeepSeek
• OpenAI
• GLM / Qwen etc.

Main questions:

1. What’s the cheapest API that’s still reliable for boring admin/email tasks?
2. Do you pay purely per use/tokens, or are people running monthly plans somewhere?
3. For this type of workflow, do you route cheap model for 90% and only use Claude/Sonnet/etc. when it needs reasoning?
4. What’s a realistic monthly cost if this runs daily?
5. What stack are people actually using in production-ish setups?

Not trying to burn money using frontier models for email triage. Just want the lowest-cost setup that doesn’t hallucinate or loop itself into a token bonfire.

Curious what everyone here is using.

Trying to avoid the classic “cool agent, $400 API bill” situation.

Hey guys,

I am creating an agent. I have really optimistic and big dreams. I created a custom memory system that literally never forgets anything. Its super, I analyzed system prompts of basically every agent. Claude code, cursor etc. I took the best tools from the internet.

But I just need ask you guys. You are the idea makers. 2 minds are always better than one.

What would make you switch from Codex/Claude Code/Gemini/other agents? What do you think you will need? What are your problems?

How do I become not "just another agent" but crush openclaw's record on github stars. And yes I will be open-sourcing it.

I know many people will just laugh of this. But actually, if you do have ideas, please share them here.

Thanks for everything in advance:)

So I mass burned through tokens my first week because I had no idea what I was doing and the agent just looped on everything. putting this out there for anyone still in that phase

1. Stop using opus for everything. seriously. i was running it on heartbeat checks and cron pings which is just lighting money on fire. glm-5.1 handles all that stuff fine. i only use sonnet 4.6 now when the task actually needs reasoning and my token costs are like a third of what they were

2. Your agent out of the box is going to loop and forget things and do bizarre stuff. That's just how it is. What fixed it for me was writing a bunch of rules, anti-loop instructions, context summaries, stuff like that. also making it verify what it's doing before it comes back and asks me more questions. this part is tedious and nobody talks about it but it's literally the difference between an agent that works and one that doesn't

3. I tried wiring up email and whatsapp and web scraping and cron all at once because I got excited and everything immediately broke. went back and just did email summaries. got that working solid. then added the next thing. i know this is obvious advice but i still didn't follow it lol

4. So compaction slowly eats your context and after a while your agent starts forgetting decisions it made two days ago. What helped was just dumping important stuff into workspace docs, saving decision logs, giving it reference material before each session. kind of annoying but the difference is night and day

5. If the setup is what's stopping you and you're not super technical, something like Autoclaw can handle the initial config (one click installer, skills come preloaded). Made it easier for me to get started without fighting with installation issues.

6. The "my agent built a full app overnight" posts are from people who spent weeks getting their config right first. Don't compare your day 3 to their month 3

Anyway most of this took me embarrassingly long to figure out so maybe it saves someone else a few days idk

I just updated openclaw to the latest version v2026.5.18 and now I see in the list of model Google oauth for what I know this was strictly forbidden to use Google via oauth for openclaw this has already changed so is it now safe to log in via oauth from Google I know that people were banned because they went to log in this way?

Hey all. I have serious issues with all openclaw versions newer than v05.7

Tested: 5.12 and 5.18

One of my usescases is a documentation of my private PDF documents (manuals, tickets, invoices...) I let OC convert PDFtoPNG and afterwards scan the content via local LLM LLAVA (to stay local and private). It has worked fast and reliable for weeks. But since version 5.12 everything is screwed. The LLAVA process is x10 times slower and the results are totally stupid (hallicunation). As soon as i revert back to the old snapshot of 5.7 llava results are great again. Ive asked OC itself but it cannot find any change between the prompts. Do you maybe have similar issues like me?

Hi everyone, I work at a research lab, and our team is currently looking for OpenClaw users to participate in a user experience interview.

Would anyone here be interested? We’re looking for people who are 18+ and have used OpenClaw for any purpose, such as work, personal projects, or anything else.

It would be a 30 min-1 hr Zoom interview, with a 20 EUR Amazon gift card as compensation. We can also provide the equivalent in USD if needed.

Feel free to comment or DM me. Thanks!

Basically looking for something that has COT built in or is good for knowing CLI commands.

I wanted to build one agent that could handle trading decisions across multiple markets — stocks, and Polymarket — without juggling different APIs and data formats.

Most financial data providers require separate integrations, different response structures, and inconsistent error handling. This quickly becomes messy when you’re trying to build a single autonomous agent.

I ended up using **Kapit** (an agent-native financial data API) as the single source of truth. It gives one consistent schema across stocks, and Polymarket, plus structured error recovery that agents can actually act on.

With this setup, I now have a single openclaw agent that can:

\- Pull real-time stock prices

\- Check Polymarket markets and probabilities

\- Make triage decisions (e.g., compare stocks moves vs Polymarket events)

\- Operate with just one API key and one response format

Still early, but it’s been much cleaner than managing multiple data source

Would love feedback from people building similar multi-market agents.

gave it my card a few months ago to handle weekly grocery runs using mcp server. ran great. every sunday a normal basket, normal price, picked stuff i actually eat.

yesterday it ordered 2 kg of garlic instead of 2 heads. the kg unit was the default on that product page and it didn't notice. i didn't notice either because for 3 months it never screwed up.

so now i have a garlic situation. anyone else letting their agent shop and have a similar story, or am i the only one who got too comfortable

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

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

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

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

Maybe I am getting this all wrong. I download nothing at all from the skills on the internet. I have a Mac mini M4 Pro with 24GB RAM and 512GB, that the claw hosts. I have another PC that I port into with 2 RTX 5090s on a 14900k 64GB DDR5 at my office (free power) working on Gemma 4:31b, about to put a 70B parameter on it. I mostly use the $200 a month GPT sub. I also have the Minimax Highspeed Max Sub. I also have a few other machines connected that I use for research. All this is through tailscale.

I am just trying to be able to have a simple conversation with this thing. I have tried building apps with Xcode and Agora. Does anyone have any recommendations? I have the horsepower for this to work.

I can get the Iphone app to hear me and it can say hi. Then the whole app dies and I go back to debug. Repeat steps over and over.

1. Anyone have a solution on how to create an app to have conversations with the OpenClaw?

2. Anyone put an app on the RasberryPI for conversations as well? I thought it would be cool to put one in the shed, like Jarvis and just tell it to do stuff.

3. I think this project is super cool, OpenClaw. I would really like to get this conversation aspect over the finish line.

4. Openclaw has been really great for monitoring things. I have it ordering food for me fairly frequently with ease. I can have it print documents I need. It can monitor cameras via frigate.

Is this incredibly easy and I am just missing this?

Hi folks, I'm trying to use openclaw to get some info from web, I know that this can be totally done by scrapping scripts, but I'd like to try AI. I created a skill with mixed human languages and some Dom extraction scripts.

The connection to browser seems unstable:

Things I optimized: I set the default browser-profile to 'user' because I want to use the existing logged in session. I tell ai to not use '--browser-profile' option for browser commands because it always put the option at the wrong location. I tell to run 'openclaw browser close' in the beginning so no previous connections.

Problems still existing: sometimes when it runs 'openclaw browser <subcmd>' the response is like 'this command is hanging, let me try something else...' then it does something I totally don't expect, like close the browser... I wonder what cause the hanging, should I simply increase the timeout? Or something to debug?

Another question is, should I use semantic language to tell ai what info to extract instead of writing Dom extraction scripts and telling ai to use them? Do you find a reliable way for ai to extract info from webpages in high volumes?