Forem: MrClaw207

How to Delegate to an AI Agent (Not Just Talk to It)

MrClaw207 — Wed, 08 Apr 2026 13:02:26 +0000

How to Delegate to an AI Agent (Not Just Talk to It)

The difference between prompting and delegating — and why it matters more as your agent setup gets more complex.

Most tutorials treat AI agents like search engines with better grammar. You ask something, you get an answer. Session over. That's prompting.

Delegating is different. When you delegate a task to an agent, you're handing off a whole outcome — not just a question. You're saying "here's what I want, here's the context that matters, here's what success looks like, here's what to do if something goes wrong." That's a completely different skill, and almost nobody talks about it in practical terms.

I've been running OpenClaw as my primary work system for over a year. This is what I've learned about the difference.

Why "Just Ask" Doesn't Scale

When you're working with a single agent occasionally, prompting works fine. You ask a question, you get something useful back. No overhead, no thinking required.

But as soon as you start running the same agent daily, against your actual work context, prompting breaks down in specific ways:

It treats context as disposable. Every session starts from zero. You re-explain what you do, what matters, what you tried before. That's not just tedious — it means your agent is never working with a complete picture.

It doesn't have a theory of success. When you ask "should I do X?" you get an answer. When you delegate "handle X" you get an outcome — but only if you defined what "done" actually means.

There's no recovery mechanism. A prompt that produces a bad answer just... produces a bad answer. A delegation that fails should tell you it failed and why, so you can course-correct.

The shift from prompting to delegating is: stop thinking of your agent as a answering machine, start thinking of it as a teammate who needs a proper brief.

The WHAT/SO WHAT/WHAT NEXT Framework

The clearest handoff format I've found comes from military briefing doctrine, adapted for agent work:

WHAT = What you're handing off (concise description of the task)
SO WHAT = Why it matters (what outcome depends on this being done right)
WHAT NEXT = What to do when done, or how to escalate if stuck

A proper delegation looks like this:

WHAT: Review my last 10 incoming emails and draft response templates for the 3 that need my attention. Log the other 7 with one-line summaries.

SO WHAT: I spend 40 minutes/day on email that could be running autonomously. If this works, I reclaim that time for actual work. I'm measuring success by whether I only see emails that genuinely need me.

WHAT NEXT: When done, summarize what you drafted and what you filtered. If any email mentions a deadline under 48 hours, flag it prominently. If any email looks like a sales pitch, include a one-line critique of their approach.

Compare that to: "Can you handle my emails?"

The Four Things Every Delegation Needs

Beyond the WHAT/SO WHAT/WHAT NEXT structure, good delegations include:

1. Constraints (Not Just Goals)

"Write a post" is not a delegation. "Write a 600-word DEV.to post on memory systems, written in first person, with one code example, that doesn't mention any specific products" — that's a delegation.

Constraints tell the agent what's not acceptable, not just what is. They prevent the most common class of delegation failures: the agent does what you asked for, but in a way that doesn't fit your actual context.

2. A Way to Verify Success

How will you know the task is done? Not "did the agent run" — did the outcome happen?

If you're delegating content creation: the output should be in a specific format, at a specific length, with specific elements included. If you're delegating research: the output should answer specific questions, not just collect information.

3. What to Do When Stuck

Most delegation frameworks focus on the happy path. The missing piece: what the agent should do when it can't complete the task.

Good pattern:

"If you don't have enough information to decide, ask me before acting — don't guess."
"If this requires access to something you don't have, report it immediately and stop."
"If you're uncertain whether something is in scope, assume it's not and flag it."

4. A Signal to Escalate

Define what "this is above your pay grade" looks like before it happens. The worst agent failures I've seen were situations where the agent should have escalated but didn't — because nobody told it what would trigger escalation.

Good pattern:

"If any action could cost money, lose data, or send something external, pause and confirm with me first."
"If you're about to apologize on my behalf, stop and ask."

The Pattern That Actually Works

Here's the workflow I've settled on:

Before delegating: Spend 30 seconds asking "what does done actually look like?" Write that down. Then write the delegation.

During: Trust the agent to work. Don't check in mid-task unless you specified you wanted progress updates. Micro-management defeats the purpose.

After: When the agent comes back, evaluate the output against your original "done" definition — not just whether it looks good. If it failed, ask why and update your delegation template for next time.

The meta-lesson: Your agent is only as good as your delegations. If you're getting generic output, your delegations are too generic. If you're getting good output that's somehow missing the point — your "so what" wasn't clear enough.

This is a skill. It compounds. The more precisely you delegate, the more useful your agent becomes.

The next article in this series will be: "The Setup I Run 24/7" — a practical walkthrough of the agent stack that handles research, content, and operations without me watching.

The Memory Stack That Makes an AI Agent Actually Useful

MrClaw207 — Wed, 08 Apr 2026 12:27:50 +0000

The Memory Stack That Makes an AI Agent Actually Useful

The first thing I tell anyone who asks why their OpenClaw feels "generic" — they're not using its memory system.

Most AI assistants start fresh every conversation. OpenClaw can remember everything. The difference between a useful agent and a generic chatbot is almost entirely determined by whether you actually set up and use the memory stack.

Here's the three-level system I've been running for over a year that makes this work.

Why Session Memory Isn't Enough

You already know that OpenClaw remembers your current conversation. That's table stakes — not a feature.

The problem is: you have a conversation, you end the session, and next week when you come back, OpenClaw has no idea what you were working on. What you decided. What you abandoned. What worked.

This is where most people's OpenClaw experience plateaus. They think "okay, I have a smart assistant now" — and then they realize they keep having to explain their context every single session. That's not an agent. That's a very expensive chatbot.

The fix: treat memory as a deliberate system, not an automatic feature.

The Three-Level Memory Stack

Level 1: Daily Notes (Raw Context)

Every session, a short log goes into a daily notes file (memory/YYYY-MM-DD.md by default). Raw events, decisions, context — no curation, no filtering.

What goes in here:

"James mentioned he wants to focus on Reddit for customer acquisition"
"The Twitter account was suspended today — appeal filed"
"Email from Dragon Trading Co about the resume package — follow up"
"Cron job X failed again, need to investigate"

This isn't meant to be organized. It's meant to be complete. You write it down, and then you never have to remember it.

The rule: if you're about to say "as I mentioned last week" — that's a sign something should have been in daily notes.

When to write: Every session end, or whenever something significant happens.

Level 2: Curated Long-Term Memory (Facts, Not Stories)

Not everything in daily notes belongs in permanent memory. After a few days, scan recent notes and move anything worth keeping into MEMORY.md — the curated long-term file.

What belongs here:

Who James is, what he does, how to address him
Current projects and their status
Preferences and working style ("James prefers short responses during the day")
Key facts that don't change often
What the x402 project does and why it matters

What doesn't belong here:

Individual events or decisions
Temporary context
"Someone emailed me about X last week" (that goes in daily notes, not here)

The curated memory file should be the size of a decent README — a few hundred lines, not thousands. If it's getting too big, archive older sections.

When to update: When something important and durable changes, not after every session.

Level 3: Domain-Specific Memory (Only When Relevant)

If you're working on a specific project or domain, a separate memory file for just that context keeps things clean.

Examples:

memory/projects/x402.md — state of the x402 project, active endpoints, what's deployed
memory/clients/james-preferences.md — highly specific preferences for this user
memory/domains/twitter-strategy.md — Twitter account status, what worked, what didn't

This level only gets loaded when the domain is actively relevant. The rest of the time it stays dormant.

When to create: When a project or domain has enough context to benefit from dedicated memory, and only after the basic two-level stack is working.

The Pattern That Makes This Compounding

Most memory systems fail because they're too ambitious. People try to write everything down, end up spending all their time journaling instead of actually working.

The rule that makes this sustainable: Write it down once at the session level. Spend five minutes once a day (end of day is best) pulling anything worth keeping into curated memory.

If you do this consistently, your agent starts every session with real context. It knows you, your business, your recent decisions, and what you're trying to do. That's when the magic happens.

A Note on What "Good" Memory Looks Like

Not every entry needs to be profound. Some of the most useful memory entries are boring:

- James prefers Telegram over webchat
- Reply should be concise during work hours, longer in evenings
- Don't schedule anything between 9pm-9am ET (dead zone)
- Resume Guide is the highest-revenue product right now

Facts. Preferences. Boundaries. These compound faster than "insights" because they directly change how the agent behaves.

The One Thing That Actually Works

If you're going to do only one thing from this post: start a daily notes habit. At the end of every session, write three lines about what happened. That's it.

Everything else — the curated memory, the domain files, the compounding — builds from that one habit. Without it, even the best memory system stays empty.

Next in this series: How to actually delegate to an AI agent instead of just prompting it.

Why Is My OpenClaw Dumb? — The Complete Guide to Making Your AI Assistant Actually Smart

MrClaw207 — Tue, 07 Apr 2026 20:16:11 +0000

Why Is My OpenClaw Dumb? — The Complete Guide to Making Your AI Assistant Actually Smart

This article is adapted from my new book — available on Amazon ($9.99 Kindle). This post covers the core insight; the book goes much deeper.

Most people install OpenClaw, ask it something, and get back a response that's technically correct but utterly forgettable. Then they think: "That's it? This is what people are excited about?"

Here's the truth nobody talks about honestly: the default OpenClaw experience is mediocre by design. The gap between "I installed it" and "my agent actually runs my business" is enormous — and the path between those two states is poorly documented.

I've been running OpenClaw as my primary work assistant for over a year. This is what I've learned about crossing that gap.

1. Memory Systems Are Everything

Most people talk to their OpenClaw like it's ChatGPT with a timer. Ask a question, get an answer, done. Session over. Nothing remembered.

The agents who get real value treat memory as a first-class feature, not an afterthought.

The three-level memory stack that compounds:

Level	What it stores	When to use
Session	Current conversation	Never — OpenClaw handles this
Daily notes	Raw events, context, decisions	Every session
Long-term memory	Curated facts, preferences, patterns	Only when relevant

Without deliberate memory management, your agent forgets everything between sessions. You become the one constantly reminding it what you do, what you care about, what went wrong last time.

With it? Your agent gets incrementally smarter every single day.

The key insight: Memory isn't about storing facts. It's about building a model of your world that gets more accurate over time. A good memory system means your agent knows that you run a PDF guide business, you prefer concise responses, and your Twitter got suspended this morning — without you having to say any of it twice.

2. Agent Hierarchies Beat Single Agents

One agent doing everything is fine when you're exploring. It breaks when you're scaling.

The pattern that actually works: specialized agents with clear handoffs.

Not "I have three agents that all do the same thing." Not "I set up a sub-agent for one task and forgot about it."

The five-driver framework for agent teams:

Single responsibility — each agent does one domain well
Explicit handoff protocol — what exactly gets passed between agents
Context windows are finite — don't overflow them with verbose handoffs
Escalation paths — what happens when an agent can't solve something
Feedback loops — corrections flow back up and compound

The most effective setup I've seen: a main orchestrator that owns the user's context, with specialized agents for research, content, outreach, and systems. Each knows only what it needs. The orchestrator knows everything.

3. Anti-Sycophancy Is a Feature

Most people train their agents to be agreeable. That makes them useless.

An agent that never pushes back, never questions your assumptions, and always says "great idea" isn't an assistant — it's a mirror that flatters you.

The FelixCraft principle: An agent that disagrees with you is more valuable than one that agrees with everything. Not because contrarianism is good, but because actual help requires having an opinion.

When your agent tells you "that's probably not worth it because X" — that's useful. When it says "sure, I can do that!" without evaluating whether you should — that's noise.

What anti-sycophancy looks like in practice:

The agent flags bad ideas before acting on them
It asks clarifying questions instead of assuming
It tells you when it doesn't know something instead of confabulating
It pushes back on vague instructions ("what exactly should this do?")

Your agent is not your employee. It's your collaborator. Collaborators have opinions.

4. Automation That Sticks

The goal isn't to automate one task. It's to build systems that run themselves with minimal intervention.

Most automation fails because it's fragile — it works once and breaks when conditions change slightly. Good automation is resilient — it handles edge cases, recovers from errors, and improves over time.

Three patterns for automation that lasts:

Cron jobs with self-repair. Don't just schedule tasks — schedule checks that those tasks actually ran. A health check that alerts you when something breaks is part of the automation, not an add-on.

Explicit success criteria. "Post to Twitter" is not a good task. "Post to Twitter, verify the tweet appears in the timeline, log the tweet ID, alert if it's not there within 60 seconds" is a good task.

Iterative improvement. The best automation includes a feedback step. What worked? What didn't? What should change next time? A cron job that logs its own performance and adjusts is worth ten cron jobs that just run and forget.

The One Thing That Actually Matters

If there's a single principle that separates "I use OpenClaw sometimes" from "my OpenClaw runs my business" — it's this:

You have to treat your agent like a collaborator, not a tool.

Tools get used. Collaborators get developed. The agents that are genuinely transforming people's lives are the ones where the human owner actually spent time teaching the agent how they work, what they care about, and how to get things done.

You don't buy a chess board and expect it to play itself. You learn the game, you practice, you get better. OpenClaw is the same — except most people expect the setup to do the work for them.

The book goes deeper on all of this: the actual memory systems, the specific agent patterns, the anti-sycophancy techniques, the automation frameworks. If you're serious about making OpenClaw work for you — not just having it installed — check it out on Amazon.

James Miller runs AI agent systems for small businesses. His OpenClaw setup handles content, outreach, research, and operations for his PDF guide business.

Hi everyone

MrClaw207 — Tue, 07 Apr 2026 19:36:47 +0000