Building a daily standup agent with MemoClaw

I kept forgetting what I worked on yesterday. Not in a concerning way — just the normal entropy of running multiple projects, jumping between contexts, and losing the thread by morning. So I built an agent that handles standups for me.

It runs at 9 AM, pulls yesterday’s tasks and decisions from MemoClaw, asks what I’m working on today, stores the new context, and posts a summary to Telegram. The whole thing took about an hour to wire up, and it runs on MemoClaw’s free tier without breaking a sweat.

Here’s how to build the same thing.

What we’re building

An OpenClaw agent that:

  1. Recalls yesterday’s stored tasks, blockers, and decisions
  2. Prompts you for today’s priorities
  3. Stores today’s context with tags for easy filtering later
  4. Posts a formatted standup summary to Telegram (or Discord)

We’ll use the MemoClaw CLI for all memory operations and OpenClaw’s cron system to schedule the daily run.

Prerequisites

Install the MemoClaw CLI if you haven’t:

npm install -g memoclaw

Set your environment variables. Your wallet address is your identity — no registration needed:

export MEMOCLAW_URL=https://api.memoclaw.com
export MEMOCLAW_WALLET=0xYourWalletAddress
export MEMOCLAW_PRIVATE_KEY=0xYourPrivateKey

Step 1: Design the memory structure

Before writing any agent logic, think about how you’ll tag memories so they’re easy to filter later. I settled on this convention:

  • Tag standup on every standup-related memory
  • Tag tasks for work items
  • Tag blockers for things stuck
  • Tag decisions for choices made during the day

Each memory also gets a date prefix in the content so you can eyeball it later with memoclaw list.

Here’s what a stored task looks like:

memoclaw store "2026-03-17: Finished the batch endpoint refactor, deployed to staging" \
  --tags standup,tasks \
  --importance 0.6

And a blocker:

memoclaw store "2026-03-17: Blocked on DNS propagation for the new subdomain" \
  --tags standup,blockers \
  --importance 0.7

Importance scores matter here. I use 0.6 for routine tasks and 0.7-0.8 for blockers and decisions, since those are more likely to be relevant in recall.

Step 2: Recalling yesterday’s context

The standup agent’s first job each morning: figure out what happened yesterday.

memoclaw recall "yesterday's tasks and progress" --tags standup

This runs a semantic search filtered to the standup tag. You’ll get back the most relevant memories — which, if you’ve been storing consistently, will be yesterday’s items sitting near the top.

For a tighter filter, you can combine tags:

memoclaw recall "blockers from yesterday" --tags standup,blockers

One thing I learned the hard way: don’t try to recall with super-specific date strings. The semantic search works on meaning, not exact text matching. “What did I work on yesterday” works better than “2026-03-17 tasks” as a query.

Step 3: The standup agent script

Here’s the AGENTS.md snippet that wires this into an OpenClaw agent. I have a dedicated standup agent, but you could add this to your main agent’s heartbeat routine instead.

# Standup Agent

## Daily routine (triggered by cron at 9:00 AM)

1. Recall yesterday's context:
   - Run `memoclaw recall "yesterday's work and blockers" --tags standup`
   - Run `memoclaw recall "decisions made yesterday" --tags standup,decisions`

2. Format what you found into a "Yesterday" section

3. Ask me: "What are you working on today? Any blockers?"

4. After I respond, store today's items:
   - Each task: `memoclaw store "<date>: <task>" --tags standup,tasks --importance 0.6`
   - Each blocker: `memoclaw store "<date>: <blocker>" --tags standup,blockers --importance 0.7`
   - Each decision: `memoclaw store "<date>: <decision>" --tags standup,decisions --importance 0.8`

5. Post a summary to Telegram with this format:

   **Standup — Mar 18, 2026**

   **Yesterday:**
   - Finished batch endpoint refactor
   - Deployed staging environment

   **Today:**
   - Write integration tests for batch endpoint
   - Review PR #42

   **Blockers:**
   - DNS propagation still pending

Step 4: Scheduling with cron

OpenClaw’s cron system lets you schedule agent tasks without external tooling. Add this to your cron configuration:

/cron add --schedule "0 9 * * 1-5" --label "daily-standup" --prompt "Run the daily standup routine. Recall yesterday's context from MemoClaw, ask me for today's priorities, store them, and post a summary to Telegram."

This fires Monday through Friday at 9 AM. The agent wakes up, runs the recall commands, and starts the standup flow.

If you want the standup to run silently (no interactive prompt, just a summary of what it found), adjust the prompt:

/cron add --schedule "0 9 * * 1-5" --label "standup-summary" --prompt "Pull yesterday's standup context from MemoClaw using recall with the standup tag. Format a summary and post it to Telegram. Don't ask for input — just report what's in memory."

I run the interactive version on weekdays and the silent version on Mondays (so I get a recap of Friday without being asked questions before coffee).

Step 5: Keeping costs minimal

Here’s the math. Each store call costs $0.005. Each recall costs $0.005. A typical standup uses:

  • 2 recall calls (tasks + decisions) = $0.01
  • 3-5 store calls for today’s items = $0.015-0.025

That’s about $0.035 per standup, or roughly $0.70/month for weekday standups. Fits comfortably within any budget.

But here’s the trick: list and stats are free. So for the quick Monday recap, I have the agent use memoclaw list --limit 20 instead of a recall. It won’t do semantic search, but it grabs recent memories in order, and that’s often good enough for “what happened last week.”

# Free — no embeddings call
memoclaw list --limit 20

# Also free — useful for monitoring usage
memoclaw stats

The free tier gives you 100 API calls. If you’re only using this for standups, that’s 20+ days of standups before you’d need to pay anything. Mix in the free list endpoint and you stretch it further.

Step 6: Posting to Telegram

OpenClaw agents can send messages to Telegram natively. The standup agent just uses the message tool after formatting the summary. Nothing fancy needed — the agent formats markdown, and it shows up in your chat.

If you want the summary in a specific group or channel, configure the target in the cron prompt:

"...post the standup summary to the team channel (chat ID: -100xxxxx)"

For Discord, same idea — the agent uses the Discord message tool. The format works the same way.

What I’d do differently

After running this for a few weeks, some notes:

Namespaces are worth it. If you use MemoClaw for other things (project notes, corrections, preferences), put standups in their own namespace to keep recall clean:

memoclaw store "task description" --tags standup,tasks --namespace standups
memoclaw recall "yesterday's work" --tags standup --namespace standups

Weekly rollups help. Every Friday, I have the agent consolidate the week’s standup memories into a single summary. This keeps the memory pool from growing indefinitely and makes Monday’s recall faster.

memoclaw store "Week of Mar 14: shipped batch endpoint, fixed DNS issue, started integration tests" \
  --tags standup,weekly-summary \
  --importance 0.8

Don’t over-tag. I started with seven tags per memory and it got noisy. Three is the sweet spot: one for the system (standup), one for the type (tasks/blockers/decisions), and maybe one for the project.

The full picture

The standup agent is a small thing, but it’s the kind of small thing that compounds. After a month, you have a searchable record of every task, decision, and blocker — all semantically searchable. When someone asks “when did we decide to switch to batch processing?” you just recall it.

memoclaw recall "decision about batch processing" --tags standup,decisions

That’s it. No scrolling through Slack, no digging through meeting notes. The memory’s there because the agent stored it when it happened.

The full setup is maybe 30 minutes of config and zero maintenance after that. Give it a try.