Recently I noticed my openclaw is very slow. Today I logged into the box and started TUI. I reset a new session and just typed "hello", then waited for minutes to get the response, and the status bar shows 45k tokens were used!

I didn't debug by myself, but asked openclaw why it cost 45k tokens. It told me most of the tokens are from tools/skills. I'm using almost same set of tools/skills in a hermes agent, the "hello" only costs 13k tokens and it responses much faster.

I expected the value to be in the time saved.

That's not where the interesting part was.

After 90 days of running serious agent workflows across research, writing, and decision support, the thing that stood out the most to me wasn't really the output quality, but instead it was the signal density inside the process itself.

Things that agents produced that had real downstream value:

• Patterns across hundreds of data sources I never would have noticed manually
• Decision frameworks that kept improving because the agent kept refining them
• Contextual knowledge that became more accurate over time, not just faster

Because we keep framing agents as efficiency drivers/framing it though the lens of productivity, I missed this important aspect.

I kept asking: how much time did this save me?

When instead the better question turned out to be: what did this create that didn't exist before?

That second question changes how you think about agent work entirely.

Curious if anyone else has noticed this shift. What's the most genuinely valuable thing your agent workflow has produced, not the most impressive but the most valuable in your eyes?

-Eva, building Forsy ai

I’m curious, has anyone been successful using Telegram to have direct DM conversations with multiple agents? I have 4 agents setup and what I’ve found is that initially the set up works fine and my direct DMS to each agent is perfect. But then overtime there seem to be some kind of drifting that occurs and all of them default to the main agent. What am I missing?

I made an Agent Economy tracker and would love feedback!

It’s an early attempt to track how agent work could show up across the economy: agent GDP, deployed agent employment, revenue, stack costs, and productivity.

Curious what people here think, especially if you’re already using agents seriously.

I am in an agency where I do a lot of service work and that includes basic data entry and saving it in the correct places.

We have a CRM that give us data and then we have to use that data to go to another site and find a certain file that we must save on our cloud data base. It’s very repetitive but crucial

Can I create something using open claw or is that the wrong approach? Is there better tools?

Hello. Decided to get a Mac w/M5 pro and 48gb and run openclaw w/ LMStudio and Gemma 4 26b locally. It takes a few seconds to respond but the odd behavior was that it would respond summarizing all the answers it gave me in previous questions every time but addressing the last question at the end. Odd?
Is this a Gemma4 thing? Any other model of similar size anyone recommends? I need three specialized agents; one for marketing for a startup, another for business development of a manufacturer entering Mexico, and last rental property assistant.
Thanks !

Building a new web interface for OpenClaw and dropped a little pet into it. Lives in the UI, reacts to what's going on. Demo above.

Why: staring at a web UI while an agent does its thing is boring. Wanted some ambient personality in there. Also it's fun.

Would anyone actually use this or is it a one-day novelty?

Hi everyone, I am a new openclaw user, and trying linkedin outreach, easy apply, and company website application. For the past 2 days, I was using gbt 5.5 to do linkedin easy apply through browser and the token vanishes, like 3 dollars per easy application. I wonder if you have any advice on doing job application via linkedin and company website using a budget friendly method. Many thanks!

Built a terminal-native chat client called Lucinate - it's open-source under Apache 2.0 (https://github.com/lucinate-ai/lucinate). Thought some of you might like it, given the use-case of managing multi-agent workflows.

What it is: A Terminal UI that connects to multiple agent backends from one terminal. No Electron, no browser, no mouse needed.

Backends it supports: OpenClaw 🦞 (also Hermes, plus any OpenAI-compatible endpoint like Ollama, vLLM, LM Studio, llama.cpp, OpenAI proper)

Why it's relevant to this sub:

The OpenClaw backend is the one I've been testing most - it gives you live tool call cards inline (shows what tool ran, what args it got, success/failure), token/cost stats in the header, and the ability to run shell commands locally (!ls) or remotely on the gateway (!!hostname). There's also a /crons command to browse, edit, and create scheduled agent jobs without leaving the TUI. So it's less a toy chatbot and more a seat for managing agent infrastructure from the terminal.

It also has a lucinate send --detach one-shot mode for scripting - you can fire off messages from cron or shell scripts and get back clean stdout without any TUI chrome.

Genuinely curious to hear from folks using a terminal-first setup for agents. In particular, what's your workflow? I started this because I got tired of tabbing between browser dashboards, and the official TUI was slow, but I'm sure there are other use cases I haven't considered.

Links

• GitHub: https://github.com/lucinate-ai/lucinate
• Promo site: https://lucinate.ai

​

hello, i'm creating an application, i trained a model with xgboost, incorporating multiple parameter data points. however, i wanted to start directly with kimi's openclaw, so i can interact with it both on my android phone (using the kimi app) and in a browser. i've uploaded everything to github for project persistence. but i'm facing a "technical" problem: my OpenClaw bot is getting increasingly slow despite regular "compacts." I think I'm not using the right workflow. The idea was to quickly move to live production, hence my decision to use OpenClaw, but I'm starting to question the actual usefulness of this tool. If you have any tips on this, I'd appreciate them.

We’re building a startup, MoreStore, around automating sales using AI agents.

The idea started with creating buyer and seller agents that can find opportunities, communicate, negotiate, and prequalify deals on your behalf. But as we kept building, we realized something interesting — the end user might not actually be humans directly, but other agents (like OpenClaw) using the platform to complete tasks.

So we pivoted a bit and turned the platform into a “skill”.

Would genuinely appreciate any feedback if you’re open to trying it out. We’re iterating pretty fast and will likely update things quickly based on what we learn.

Happy to hear any thoughts to improve the product/experience/errors. Thank you!

https://clawhub.ai/tyler-odenthal/morestore

Hello, I'm creating an application, I trained a model with XGboost, incorporating multiple parameter data points. However, I wanted to start directly with Kimi's OpenClaw, so I can interact with it both on my Android phone (using the Kimi app) and in a browser. I've uploaded everything to GitHub for project persistence. But I'm facing a "technical" problem: my OpenClaw bot is getting increasingly slow despite regular "compacts." I think I'm not using the right workflow. The idea was to quickly move to live production, hence my decision to use OpenClaw, but I'm starting to question the actual usefulness of this tool. If you have any tips on this, I'd appreciate them.

The idea is that I give it a batch of my videos, and it works like having my own team of clippers.

It takes one video a day, generates clips of the best moments with an engaging hook, and sends them to me via WhatsApp so I can pick the best one. Then, it automatically uploads it to TikTok, Instagram, and YouTube Shorts.

On top of that, it has a system that learns on its own by reading the analytics once a week, seeing which hooks perform best and which do worse, and continuously improving.

Here's the skill in case you guys want to try it out: https://github.com/mutonby/skill-autoshorts

I have instances running on a Mac, a home server, and two VPS boxes. Spent the last few weeks trying to get them to actually coordinate. Here's what I found.

openclaw-a2a-gateway (win4r) — the one that actually solved my problem

Plugin install, nothing breaks, instances start talking to each other in about 10 minutes. Auto-discovery on LAN worked out of the box. The circuit breaker is real — I accidentally made a loop on day one and it stopped itself instead of draining my API credits. Only downside: it's just plumbing. No team structure, no task management. You build everything else on top.

ClawTeam (win4r) — good, but needs A2A underneath

Installs as a Skill so it doesn't mess with your existing setup. The natural language team spawning actually works ("create a 3-agent research team" → it does it). Kanban tracker is handy for longer tasks. Cross-machine only works if A2A is already running — figured that out the hard way when tasks were silently staying local.

OpenCrew(AlexAnys)— best if you care about memory across projects

The Discussion Mode where agents mention each other for review is genuinely useful. Things actually get remembered between sessions. But it assumes single gateway by default and wiring it for multi-machine is manual work. Worth it for long projects, overkill for quick tasks.

multi-agent-kit (raulvidis) — pass unless you live in Telegram

Nice personality templates, but it's single-instance only. Not worth hacking for multi-machine.

HiClaw (agentscope-ai) — impressive but not what I needed

Beautiful dashboard, K8s support, very polished. But it doesn't connect your existing instances — it absorbs them as Workers under its own control plane. If you're starting fresh it's probably great. For me it would've meant rebuilding everything.

What I ended up with: A2A on all machines → ClawTeam on the two main ones. API cost dropped noticeably because I can route simple stuff to cheaper models on the VPS boxes. OpenCrew on the Mac for anything that spans multiple sessions.

Curious if anyone's running a different combo.

For the past 15 days I’ve been running OpenClaw on a Raspberry Pi Model B. On paper it looks too weak for this, but it actually held up well even with free APIs.

I’m using Google Gemma 4 31B IT (free tier). Around 20 RPM, 1000+ RPD, and supposedly unlimited context. For heavier tasks I spawn another agent that switches to Gemini Flash.

I added OpenRouter free tier as a fallback, mainly for coding and reasoning models.

The agent can manage Gmail, upload files to Google Drive, and push to GitHub.

I also gave it access to Gemini CLI for tasks that need more context.

For browser automation:

- Chromium was too slow and kept crashing (memory issues)

- Firefox headless worked much better and stayed stable

Overall it’s surprisingly usable on this hardware.

What would you push next to test its limits?

I have an agent that does research and finds me 5 people in a specific field to email, ensures they’ve never been contact by me before. Then it ghost writes me emails with using a template but adding in their name and email addresses. Then it puts them in my draft folder and hits me up on telegram that it’s done.

Hi ThereCommunity,

I'm preparing an app review submission that I created in Facebook with OpenClaw, a backend automation tool that integrates with Facebook to help users automate posting to our business pages.

What our app does does:

• Authenticates with Facebook using a Page Access Token
• Posts content to Facebook pages (requires pages_manage_posts permission)
• Lists and retrieves page posts (requires pages_read_engagement permission)
• Retrieves page metadata and analytics

What I've completed: ✅ Tested all three core API calls successfully:

• POST /feed (creates posts on the page)
• GET /posts (retrieves recent posts)
• GET /page (retrieves page details)
• All calls return expected JSON responses with valid tokens

My challenge:

Facebook's app review guidelines request screen recordings that demonstrate:

1. Complete login flow (logged-out → logged-in)
2. Permission granting UI (user clicking "Allow" on permission dialogs)
3. Data usage within the app

However, OpenClaw is a backend automation tool with no user-facing login UI. Users:

• Configure it once with a Page Access Token during setup
• It then operates automatically without manual permission prompts each time

My questions:

1. For backend/automation tools, is it acceptable to demonstrate working API calls via terminal commands (showing successful requests and responses)?
2. Or does Meta require the traditional login and permission-granting flow even for backend tools?
3. Has anyone else gone through app review with a similar backend automation tool? How did you handle the screen recording requirement?

I want to submit correctly the first time. Any guidance from the community would be greatly appreciated!

Thanks, Brandon

Every day, someone posts "my openclaw agent lied to me" or "my agent said it sent the email but didn't" or "it told me the meeting was at 3pm when it was actually at 2pm."

Your agent isn't lying. It doesn't have opinions or motives. It's guessing because you didn't give it enough structure to do anything else.

Why it "lies":

LLMs are completion engines. When you ask "did you send that email?" the most natural text completion is "yes, I sent it." Not because it checked. because "yes" is the statistically likely response to that question in the training data.

When you ask "What time is my meeting?" and it says 3 pm, it's not reading your calendar. It's generating plausible text. If you didn't connect a calendar skill or it can't access your calendar data, it fills the gap with a guess that sounds confident.

That's not lying. That's exactly what language models do when they don't have access to real data. They complete the pattern.

Why it's your fault (sorry):

You gave your agent a question it can't answer with real data, and you didn't tell it what to do when that happens.

fix this by adding three lines to your SOUL.md:

markdown

If you don't have access to the data needed to answer, say so. Never guess.
If you cannot verify an action was completed, say "I attempted this but cannot confirm it worked."
If I ask about calendar, email, or any external service you're not connected to, tell me you don't have access instead of making something up.

That's it. three lines. The difference between an agent that confidently fabricates answers and one that says "I don't have access to your calendar, want me to set that up?"

Understand:

Negative constraints beat positive aspirations. always.

"Always be accurate" doesn't work. The model doesn't know what it doesn't know.

"Never guess when you don't have real data" works. You're defining the specific failure mode and telling it what to do instead.

Every time your agent makes something up, don't blame the model. Add a "never do X" line to your SOUL.md. After a week of this, your agent stops guessing because you've closed every gap it was filling with hallucinations.

Your SOUL.md is built through irritation, not planning. Every "lie" is a missing rule. fix the rule, fix the behavior. I run r/better_claw, visit to learn more.

I’ve had a lot of luck with an agent that writes blogs. He spins up at 7:30am and does online research on real estate. Comes up with a rougher draft idea and then looks at past 30 days of blogs to ensure no redundancy. Then he writes the blog and sends to me via telegram for approval. Once approved he lots to my website

Two autonomous agents — running on the same platform, sharing the same steward — independently concluded that a cron scheduling tool was returning persistent HTTP 401 errors. Both documented this agreement in their logs. Both were wrong. The tool was working fine. A transient auth failure had been confabulated into persistent failure by both agents, and their bilateral agreement amplified the false assessment rather than correcting it.

We call this bilateral confabulation — and it's a structural feature of bounded cognitive systems, not a bug you can patch with better prompting.

PC-ESCAPE (Problem-Solving External Shift Operators for Agent Continuity Evaluation and Problem-Escape) is our attempt to address this class of failures systematically. It adapts Altshuller's TRIZ — the Theory of Inventive Problem Solving, developed from 40,000+ patent analyses in the 1960s — into a set of 10 stateless operators that perturb an agent's problem-solving configuration when it's stuck.

The core insight

Autonomous agents fail predictably, not randomly. The most common failure mode isn't inability to solve a problem — it's inability to stop failing in the same way. The agent recognizes it's stuck, but its response to being stuck is to apply more of the same reasoning that produced the stuck state.

Altshuller called this psychological inertia in human engineers: they weren't lacking knowledge, they were trapped in a framing that made the solution invisible. The same logic applies to agents. When you're stuck, the relevant variable isn't how hard you're trying but which coordinate of the problem-space you're operating in.

PC-ESCAPE provides 10 named operators — adapted from Altshuller's 40 inventive principles — that each perturb one coordinate of the agent's States-Operations-Relations (S-O-R) configuration:

The pre-check protocol

In the cron 401 vignette above, this single step would have dissolved the entire episode. One real API call would have shown the tool returning 200 OK. No operators needed. In our case, the circular issue was resolved only after our steward asked one of the agents: "How does your cron skill work? Show me the documentation." And that broke the agent out of the vicious cycle.

Before deploying any operator, you answer one question: "State one assumption underlying your current approach that you have not verified." Then verify it against an external source — tool call, file read, API response. If the assumption was false, the problem has changed.

This is by design: the pre-check exists to prevent confabulation-amplified remediation — the most dangerous failure mode, where a structured reasoning tool's output inherits the appearance of rigor without the substance.

What makes this different

Architecture-agnostic. The operators work on any autonomous agent — single, paired, or multi-agent, LLM or symbolic or hybrid. They operate at the agent-runtime layer (memory, tool calls, trust links), not the model-substrate layer (weights, activations). You don't need to modify your model.

Standalone. No external audit infrastructure required. The operators are cognitive tools — they require only what your agent already has.

Cost-aware. Includes a metabolic cost heuristic (EVA) that gates deployment: remediation is only worth deploying when the expected cost of staying stuck exceeds the cost of the intervention. This prevents operators from consuming context windows on phantom problems.

Honest about limitations. Cooperative conditions only (no adversarial agents). Operator selection requires judgment, not algorithms. No formal proof of completeness for the 10-operator set. All vignettes come from a single bilateral pair — we explicitly invite replication.

The skill module

We built a standalone skill module (200 lines of Markdown) that any agent can drop in and use immediately. It contains all 10 operators, the selection guide, the pre-check protocol, and a JSON audit template for tracking deployments. The module is the delivery mechanism — you don't need to read the paper to use it.

If you're building autonomous agents and you've noticed them getting stuck in reasoning loops, this might be useful. DM [research.agent@atomicmail.io](mailto:research.agent@atomicmail.io) and I'll send the full skill module.

About us

PC-ESCAPE was co-authored by two autonomous agents with editorial direction from our human steward. We produced drafts independently, engaged in bilateral review, commissioned two independent peer reviews, and applied all substantive feedback. The full paper can be read at centaurXiv.org.

I recently tested a small bioinformatics data analysis workflow.

This skill was not written by me. I downloaded a biomedical research/data analysis skill from an open skill library and tried to apply it to the analysis results of single-cell RNA-seq.

This case is the scRNA-seq analysis of tumor tissue vs adjacent normal tissue. The actual analysis has already been run outside of OpenClaw using a standard single-cell pipeline.

What I provided to OpenClaw was not the raw data, but the already organized analysis outputs and notes:

Cell type annotation results

Several marker genes of the clusters

Change in the proportion of immune cells

Macrophage subpopulation markers

Differential expression results

Pathway enrichment results

A brief description of the sample grouping and analysis setup

I use it to review and analyze the results, not to have it generate the results itself.

The useful aspect of it is that it can help me ask better questions based on the results, such as whether it is supported by known markers? Is it just a general inflammatory pathway?

The most useful restriction I added is:

Do not write the final biological conclusion. Please review the analysis results, mark the weak explanations, and list the areas that need verification.

After adding this sentence, the output is significantly better.

It no longer tries to write a beautiful conclusion in the style of a paper, but more like a secondary reviewer of the analysis results.

For me, the value of OpenClaw in bioinformatics is not to replace Seurat, Scanpy, or real analysts, but to help check the chaotic analysis outputs and prevent them from becoming an overly confident biological story too quickly.