7 Things Nobody Tells You About OpenClaw
Summarize content with
Most OpenClaw setup guides get you to "it's running." What they don't cover is what separates a setup that's occasionally useful from one that actually changes how you work. These are the things most people figure out the hard way.
01. Run it on a cheap server, not your laptop
This sounds obvious but most people skip it. If OpenClaw lives on your machine, it only works when your machine is on. Close your laptop and the agent goes offline. Cron jobs don't fire. Heartbeat doesn't run. You end up with a chatbot you have to babysit, not an autonomous agent.
Spin up a VPS. Hetzner's CX22 instance runs about €5-7/month and has better security defaults than most local setups. OpenClaw runs 24/7, works while you sleep, and doesn't care if you close your laptop.
This is the single biggest unlock for actually getting value out of it. Everything else builds on top of a server that's always on.
If you're on the fence about the cost: your agent running a morning briefing cron, monitoring your tools overnight, and catching one broken automation before a customer does will pay for the server in the first week.
02. Use your main agent as an orchestrator
The default instinct is to build one agent and give it everything. That's where things get messy fast. One agent with access to your email, your calendar, your Notion, your Slack, and your research tools is an agent that doesn't know what its actual job is.
Set up your main agent as an orchestrator instead. Give it high-level context, a clear decision framework, and the ability to delegate. Then build subagents that each have their own tools and live in separate Slack channels or Telegram topics. One subagent handles research. Another handles outreach. Another runs overnight reviews.
The main agent decides what needs doing and routes it. It doesn't do everything itself. This keeps each agent's scope clean, makes failure modes easier to diagnose, and means you're not burning expensive model calls on tasks that don't need them.
03. Fix the memory properly
Out of the box, OpenClaw's retrieval is weak. The default embedding setup will pull the wrong context, miss relevant history, and give your agent a short effective memory even though the files are all there.
Install the lossless claw plugin and ask it to set up three memory tiers:
- Hot memory: recent context that stays in active retrieval
- Context memory: medium-term working knowledge, decisions made, patterns observed
- Archive memory: long-term storage that gets surfaced when relevant
Then switch to a paid embedding model. The difference is significant. With proper embeddings, your agent actually surfaces the right context at the right time instead of hallucinating based on proximity.
This is the part most setups skip and then wonder why the agent feels dumb three weeks in.
04. Don't run everything through your best model
Heartbeats, cron checks, and routine monitoring tasks don't need Opus or Sonnet. They're doing lightweight work: checking a checklist, pulling context, deciding if anything is worth escalating. Running your strongest model on all of that is expensive and unnecessary.
Set up model tiers. Use a cheaper model like Gemini Flash for general tasks and keep the stronger model as a fallback for anything that actually requires judgment: complex research, decision-making, tasks that need nuanced context.
Most agents end up doing 80% routine work and 20% work that needs real intelligence. Pricing that correctly makes the whole setup more sustainable and means you're not rationing API calls.
05. Your agent needs rules. A lot of them.
Out of the box, OpenClaw is dumb. Not the model, but the behavior. Without explicit rules, it will loop on tasks it can't complete, repeat questions you've already answered, forget decisions it made an hour ago, and ask you things it should be able to figure out itself.
Create SKILL.md files in your workspace/skills/ folder. These are instruction sets that tell the agent exactly how to behave in specific situations:
- Anti-looping rules: if a task fails twice, escalate don't retry
- Compaction summaries: before context gets cut, write a structured handoff
- Task-checking: look in active task files before asking the user a question
- Escalation logic: what warrants interrupting vs. handling silently
The agents that actually work well are the ones with the most rules, not the least. Think of it as onboarding a new team member. The more precisely you define the job, the less you have to supervise it.
A useful starting point: ask the agent to audit the last 10 times it interrupted you and write rules to handle each of those situations autonomously. It will write better rules than most people do manually.
06. Start with ONE integration working end-to-end
The setup guides make it look straightforward to connect email, calendar, Telegram, web scraping, and Notion all at once. Don't do this.
Every integration is a separate failure mode. OAuth tokens expire. API rate limits hit. Webhooks stop firing. When you have six integrations and something breaks, you have no idea where to look. And something will break.
Get one workflow running perfectly first. A morning briefing cron that pulls your top Notion tasks and messages you at 8am is a real workflow. It has inputs, outputs, and a clear success condition you can verify every morning.
Once that's solid, add the next integration. Then the next. Each one you add, you understand. Each failure you hit, you can diagnose. The people who end up with powerful setups are usually the ones who moved slower at the start.
07. Save what works into persistent state files
Compaction is OpenClaw's biggest structural weakness. Every time the context window gets compressed, your agent loses ground. Decisions it made, preferences it learned, workflows it refined can all get wiped, and you're back to re-explaining yourself.
The fix is putting important information somewhere that survives compaction. Use these files in your workspace docs/ folder:
- USER.md: your preferences, work style, timezone, communication patterns
- AGENTS.md: each agent's role, personality, tools, escalation rules
- HEARTBEAT.md: the standing checklist and any decisions about monitoring priorities
Anything your agent had to learn once should go into a file it can read at the start of every session. The less it has to re-learn, the more every conversation builds on the last one instead of starting over.
This is the difference between an agent that gets smarter over three months and one that stays the same mediocre assistant it was on day one.
The setup that actually works
A VPS that's always on. An orchestrator with scoped subagents. Proper embeddings and memory tiers. Model routing that matches cost to task complexity. Explicit behavioral rules. One integration at a time. Persistent state files that survive compaction.
None of this is complicated. All of it is skipped by most setups. The gap between "OpenClaw is running" and "OpenClaw is actually useful" is almost entirely in these details.
Get the infrastructure right first. Then build on it.
Want help setting up OpenClaw the right way? Book strategy call and we'll map out exactly what to build.
