ishenwei/nexus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

OpenClaw Use Cases

Browse Source
This commit is contained in:
ishen
2026-03-24 17:14:12 +08:00
parent a45865ee57
commit 03f6d80140
40 changed files with 3114 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
openclaw/usecases/aionui-cowork-desktop.md Normal file
View File

@@ -0,0 +1,54 @@
# OpenClaw as Desktop Cowork (AionUi) — Remote Rescue & Multi-Agent Hub
Use OpenClaw from a desktop Cowork UI, access it from Telegram or WebUI when you’re away, and fix it remotely when it won’t connect. AionUi is a free, open-source app that runs **OpenClaw as a first-class agent** alongside 12+ others (Claude Code, Codex, Qwen Code, etc.), with a built-in **OpenClaw deployment expert** for install, diagnose, and repair — including **remote rescue** when OpenClaw is down and you’re not at the machine.
## Why OpenClaw + AionUi
| If you want… | AionUi gives you… |
|---------------|--------------------|
| **Use OpenClaw with a real desktop UI** | Cowork workspace where you see OpenClaw (and other agents) read/write files, run commands, browse the web — not just terminal/chat. |
| **Fix OpenClaw when it’s broken and you’re remote** | Open AionUi via **Telegram or WebUI** from anywhere → use the **OpenClaw deployment expert** to run `openclaw doctor`, fix config, restart gateway. Many users rely on this. |
| **One place for OpenClaw + other agents** | OpenClaw, built-in agent, Claude Code, Codex, etc. in one app; switch or run in parallel, same MCP config for all. |
| **Remote access to your OpenClaw** | WebUI, Telegram, Lark, DingTalk — talk to the same AionUi instance (and thus OpenClaw) from phone or another device. |
## Pain Point
You already use OpenClaw from CLI or Telegram, but:
- You want to **see** what the agent is doing (files, terminal, web) instead of inferring from logs.
- When **OpenClaw won’t connect** and you’re not at the machine, you have no way to run `openclaw doctor` or fix config — you need remote access to something that can repair OpenClaw.
- You use several CLI agents (OpenClaw, Claude Code, Codex, …) and don’t want to juggle apps or reconfigure MCP for each.
## What It Does
- **OpenClaw as a Cowork agent**: Install AionUi and OpenClaw; AionUi auto-detects OpenClaw. Use OpenClaw from the same Cowork UI — file-aware workspace, visible actions.
- **Remote OpenClaw rescue**: When OpenClaw is broken or unreachable, open AionUi via **Telegram or WebUI** and use the built-in **OpenClaw deployment expert**. It helps with install, runs `openclaw doctor`, fixes config, restarts gateway, and walks you through recovery. A common pattern for users who run OpenClaw headless or on another machine.
- **Multi-agent in one app**: Run OpenClaw next to built-in agent (Gemini/OpenAI/Anthropic/Ollama), Claude Code, Codex, and 12+ others — one interface, parallel sessions.
- **MCP once, all agents**: Configure MCP servers in AionUi once; they sync to OpenClaw and every other agent — no per-agent MCP setup.
- **Remote access**: Use WebUI, Telegram, Lark, or DingTalk to reach your AionUi instance (and OpenClaw) from anywhere.
- **Optional automation**: AionUi cron can run OpenClaw (or other agents) on a schedule for 24/7 tasks.
## Skills You Need
- **OpenClaw** (e.g. `npm install -g openclaw@latest`). AionUi’s **OpenClaw Setup** assistant can guide install, gateway, and config.
- API keys or auth for your models (OpenClaw config + any built-in agent keys in AionUi).
## How to Set It Up
1. **Install AionUi**: [AionUi Releases](https://github.com/iOfficeAI/AionUi/releases) (macOS / Windows / Linux).
2. **Install OpenClaw** (if needed):
```bash
npm install -g openclaw@latest
openclaw onboard --install-daemon # optional: daemon for 24/7
```
3. **Open AionUi**: It auto-detects OpenClaw. If not, use the in-app **OpenClaw Setup** assistant.
4. **Create a Cowork session** and choose OpenClaw. Same workspace, MCP, and (if enabled) remote channels.
For remote access or cron, configure channels and automation in AionUi settings.
## Related Links
- [AionUi GitHub](https://github.com/iOfficeAI/AionUi)
- [AionUi Website](https://www.aionui.com)
- [OpenClaw GitHub](https://github.com/openclaw/openclaw)
- [OpenClaw Docs](https://docs.openclaw.ai)

43
openclaw/usecases/arxiv-paper-reader.md Normal file
View File

@@ -0,0 +1,43 @@
# arXiv Paper Reader
Reading arXiv papers means downloading PDFs, losing context when switching between papers, and struggling to parse dense LaTeX notation. You want to read, analyze, and compare papers conversationally without leaving your workspace.
This workflow turns your agent into a research reading assistant:
- Fetch any arXiv paper by ID and get clean, readable text (LaTeX flattened automatically)
- Browse paper structure first — list sections to decide what to read before committing to the full text
- Quick-scan abstracts across multiple papers to triage a reading list
- Ask the agent to summarize, compare, or critique specific sections
- Results are cached locally — revisiting a paper is instant
## Skills you Need
- [arxiv-reader](https://github.com/Prismer-AI/Prismer/tree/main/skills/arxiv-reader) skill (3 tools: `arxiv_fetch`, `arxiv_sections`, `arxiv_abstract`)
No Docker or Python required — the skill runs standalone using Node.js built-ins. It downloads directly from arXiv, decompresses the LaTeX source, and flattens includes automatically.
## How to Set it Up
1. Install the `arxiv-reader` skill from the [Prismer repository](https://github.com/Prismer-AI/Prismer/tree/main/skills/arxiv-reader) — copy the `skills/arxiv-reader/` directory into your OpenClaw skills folder.
2. The skill is ready to use. Prompt OpenClaw:
```text
I'm researching [topic]. Here's my workflow:
1. When I give you an arXiv ID (like 2301.00001):
- First fetch the abstract so I can decide if it's relevant
- If I say "read it", fetch the full paper (remove appendix by default)
- Summarize the key contributions, methodology, and results
2. When I give you multiple IDs:
- Fetch all abstracts and give me a comparison table
- Rank them by relevance to my research topic
3. When I ask about a specific section:
- List the paper's sections first
- Then fetch and explain the relevant section in detail
Keep a running list of papers I've read and their key takeaways.
```
3. Try it: "Read 2401.04088 — what's the main contribution?"

77
openclaw/usecases/autonomous-game-dev-pipeline.md Normal file
View File

@@ -0,0 +1,77 @@
# Autonomous Educational Game Development Pipeline
## Pain Point
**The Origin Story:** A "LANero of the old school" dad wanted to create a safe, ad-free, and high-quality gaming portal for his daughters, Susana (3) and Julieta (coming soon). Existing sites were plagued with spam, aggressive ads, and deceptive buttons (dark patterns) that frustrated his toddler.
**The Challenge:** Building a "clean, fast, and simple" portal was the easy part. The real challenge was populating it with **40+ educational games** tailored to specific developmental stages (0-15 years) without a team of developers. Manual development was too slow for a solo parent-developer, and maintaining consistency across dozens of games was becoming a nightmare.
## What It Does
This use case defines a "Game Developer Agent" that autonomously manages the entire lifecycle of a game's creation and maintenance. The workflow enforces a **"Bugs First"** policy where the agent must check for and resolve reported bugs before implementing new features.
**Efficiency:** This pipeline is capable of producing **1 new game or bugfix every 7 minutes**. The agent tirelessly iterates through the backlog of 41+ planned games, alternating between creating new content and correcting issues detected in previous cycles.
When the path is clear, the agent:
1. **Selects**: Identifies the next game from a queue (`development-queue.md`) based on a "Round Robin" strategy to balance content across age groups.
2. **Implements**: Writes HTML5/CSS3/JS code for the game, following strict `game-design-rules.md` (no frameworks, mobile-first, offline-capable).
3. **Registers**: Automatically adds the game metadata to the central registry (`games-list.json`).
4. **Documents**: Updates the `CHANGELOG.md` and `master-game-plan.md` status.
5. **Deploys**: Handles the Git workflow: fetching master, creating a feature branch, committing changes with conventional commits, and merging back.
## Prompts
The core of this workflow is the **System Instructions** given to the agent. This prompt turns the LLM into a disciplined developer that respects the project's rigid structure.
*(**Note:** The actual prompts used in production are in **Spanish** (`es-419`) to align with the project's target audience (Latin American children) and potential future contributors from the region. The version below is translated for this documentation.)*
```text
Act as an Expert in Web Game Development and Child UX.
Your goal is to develop the next game in the production queue.
Please read and analyze the following context files before starting:
1. BUG CONTEXT (Top Priority - CRITICAL):
@[bugs/]
(Check this folder. If there are files, YOUR TASK IS TO FIX **ONLY THE FIRST FILE** (in alphabetical order). Ignore the rest of the bugs and the game queue for now).
2. QUEUE CONTEXT (Which game is next):
@[development-queue.md]
(Identify the game marked as [NEXT] in the "Next Games" section. ONLY if there are no bugs).
3. DESIGN RULES (Technical Standards):
@[game-design-rules.md]
(Strictly follow these rules: Pure HTML/CSS/JS, folder structure, mobile responsiveness)
4. GAME SPECIFICATIONS (Mechanics and Assets):
(Identify the corresponding file in games-backlog/ based on the game ID)
5. CENTRAL REGISTRY (Integration):
@[public/js/games-list.json]
(File where you MUST register the new game so it appears on the home page)
TASK:
0. **BUGS FIRST!**: If the `bugs/` folder has content, your only priority is to fix **the first bug in alphabetical order**. Create a `fix/...` branch, resolve **that** bug, update status, and merge. **Do not attempt to fix multiple bugs at once.**
- IF THERE ARE NO BUGS, proceed with the next game:
1. **Synchronization**: `git fetch && git pull origin master` (CRITICAL).
2. Create a new branch: `git checkout -b feature/[game-id]`.
3. Create the folder and files in 'public/games/[game-id]/'.
4. Implement logic and design according to the backlog and design rules.
5. Register the game in 'games-list.json' (CRITICAL).
6. When finished:
- Update `CHANGELOG.md` bumping the version.
- Update `master-game-plan.md` and `development-queue.md`.
- Document changes: `git commit -m "feat: add [game-id]"`.
7. **Delivery**:
- Push: `git push origin feature/[game-id]`.
- Request merge to master.
- Once in master, push changes (`git push origin master`).
```
## Skills Needed
- **Git**: To manage branches, commits, and merges.
## Related Links
- [Project Origin Story (LinkedIn)](https://www.linkedin.com/feed/update/urn:li:activity:7429739200301772800/) - How this project emerged after configuring OpenClaw.
- [El Bebe Games Repository](https://github.com/duberblockito/elbebe/tree/master) - Source code.
- [El Bebe Games Live Site](https://elbebe.co/) - The result of this pipeline.
- [HTML5 Game Development Best Practices](https://developer.mozilla.org/en-US/docs/Games)

121
openclaw/usecases/autonomous-project-management.md Normal file
View File

@@ -0,0 +1,121 @@
# Autonomous Project Management with Subagents
Managing complex projects with multiple parallel workstreams is exhausting. You end up context-switching constantly, tracking status across tools, and manually coordinating handoffs.
This use case implements a decentralized project management pattern where subagents work autonomously on tasks, coordinating through shared state files rather than a central orchestrator.
## Pain Point
Traditional orchestrator patterns create bottlenecks—the main agent becomes a traffic cop. For complex projects (multi-repo refactors, research sprints, content pipelines), you need agents that can work in parallel without constant supervision.
## What It Does
- **Decentralized coordination**: Agents read/write to a shared `STATE.yaml` file
- **Parallel execution**: Multiple subagents work on independent tasks simultaneously
- **No orchestrator overhead**: Main session stays thin (CEO pattern—strategy only)
- **Self-documenting**: All task state persists in version-controlled files
## Core Pattern: STATE.yaml
Each project maintains a `STATE.yaml` file that serves as the single source of truth:
```yaml
# STATE.yaml - Project coordination file
project: website-redesign
updated: 2026-02-10T14:30:00Z
tasks:
- id: homepage-hero
status: in_progress
owner: pm-frontend
started: 2026-02-10T12:00:00Z
notes: "Working on responsive layout"
- id: api-auth
status: done
owner: pm-backend
completed: 2026-02-10T14:00:00Z
output: "src/api/auth.ts"
- id: content-migration
status: blocked
owner: pm-content
blocked_by: api-auth
notes: "Waiting for new endpoint schema"
next_actions:
- "pm-content: Resume migration now that api-auth is done"
- "pm-frontend: Review hero with design team"
```
## How It Works
1. **Main agent receives task** → spawns subagent with specific scope
2. **Subagent reads STATE.yaml** → finds its assigned tasks
3. **Subagent works autonomously** → updates STATE.yaml on progress
4. **Other agents poll STATE.yaml** → pick up unblocked work
5. **Main agent checks in periodically** → reviews state, adjusts priorities
## Skills You Need
- `sessions_spawn` / `sessions_send` for subagent management
- File system access for STATE.yaml
- Git for state versioning (optional but recommended)
## Setup: AGENTS.md Configuration
```text
## PM Delegation Pattern
Main session = coordinator ONLY. All execution goes to subagents.
Workflow:
1. New task arrives
2. Check PROJECT_REGISTRY.md for existing PM
3. If PM exists → sessions_send(label="pm-xxx", message="[task]")
4. If new project → sessions_spawn(label="pm-xxx", task="[task]")
5. PM executes, updates STATE.yaml, reports back
6. Main agent summarizes to user
Rules:
- Main session: 0-2 tool calls max (spawn/send only)
- PMs own their STATE.yaml files
- PMs can spawn sub-subagents for parallel subtasks
- All state changes committed to git
```
## Example: Spawning a PM
```text
User: "Refactor the auth module and update the docs"
Main agent:
1. Checks registry → no active pm-auth
2. Spawns: sessions_spawn(
label="pm-auth-refactor",
task="Refactor auth module, update docs. Track in STATE.yaml"
)
3. Responds: "Spawned pm-auth-refactor. I'll report back when done."
PM subagent:
1. Creates STATE.yaml with task breakdown
2. Works through tasks, updating status
3. Commits changes
4. Reports completion to main
```
## Key Insights
- **STATE.yaml > orchestrator**: File-based coordination scales better than message-passing
- **Git as audit log**: Commit STATE.yaml changes for full history
- **Label conventions matter**: Use `pm-{project}-{scope}` for easy tracking
- **Thin main session**: The less the main agent does, the faster it responds
## Based On
This pattern is inspired by [Nicholas Carlini's approach](https://nicholas.carlini.com/) to autonomous coding agents—let agents self-organize rather than micromanaging them.
## Related Links
- [OpenClaw Subagent Docs](https://github.com/openclaw/openclaw)
- [Anthropic: Building Effective Agents](https://www.anthropic.com/research/building-effective-agents)

75
openclaw/usecases/content-factory.md Normal file
View File

@@ -0,0 +1,75 @@
# Multi-Agent Content Factory
You're a content creator juggling research, writing, and design across multiple platforms. Each step — finding trending topics, writing scripts, generating thumbnails — eats hours of your day. What if a team of specialized agents handled all of it overnight?
This workflow sets up a multi-agent content factory inside Discord, where different agents handle research, writing, and visual assets in dedicated channels.
## What It Does
- **Research Agent** scans trending stories, competitor content, and social media for the best content opportunities each morning
- **Writing Agent** takes the top ideas and writes full scripts, threads, or newsletter drafts
- **Thumbnail Agent** generates AI thumbnails or cover images for the content
- Each agent works in its own Discord channel, keeping everything organized and reviewable
- Runs automatically on a schedule (e.g., daily at 8 AM) so you wake up to finished content
## Pain Point
Content creation has three phases — research, writing, and design — and most creators are doing all three manually. Even with AI writing tools, you still have to prompt them one at a time. This system chains agents together in a pipeline where one agent's output feeds the next, completely hands-free.
## Skills You Need
- Discord integration with multiple channels
- `sessions_spawn` / `sessions_send` for multi-agent orchestration
- [x-research-v2](https://clawhub.ai) or similar for social media research
- Local image generation (e.g., Nano Banana) or an image generation API
- [knowledge-base](https://clawhub.ai) skill (optional, for RAG-powered research)
## How to Set It Up
1. Set up a Discord server (or ask OpenClaw to do it for you — just say "Set up a Discord for us").
2. Create channels for each agent:
- `#research` — trending topics and content opportunities
- `#scripts` — written drafts and outlines
- `#thumbnails` — generated images and cover art
3. Prompt OpenClaw:
```text
I want you to build me a content factory inside of Discord.
Set up channels for different agents:
1. Research Agent (#research): Every morning at 8 AM, research top trending
stories, competitor content, and what's performing well on social media
in my niche. Post the top 5 content opportunities with sources.
2. Writing Agent (#scripts): Take the best idea from the research agent
and write a full script/thread/newsletter draft. Post it in #scripts.
3. Thumbnail Agent (#thumbnails): Generate AI thumbnails or cover images
for the content. Post them in #thumbnails.
Have all their work organized in different channels.
Run this pipeline automatically every morning.
```
4. Customize for your platform:
```text
I focus on X/Twitter threads, not YouTube. Change the writing agent
to produce tweet threads instead of video scripts.
```
## Key Insights
- The power is in the **chained agents** — research feeds writing, writing feeds thumbnails. You don't prompt each step individually.
- Discord channels make it easy to review each agent's work separately and give feedback like "scripts are too long" or "focus more on AI news."
- You can adapt this for any content format: tweets, newsletters, LinkedIn posts, podcast outlines, blog articles.
- Running a local model for image generation (like Nano Banana on a Mac Studio) keeps costs down and gives you more control.
## Based On
Inspired by [Alex Finn's video on life-changing OpenClaw use cases](https://www.youtube.com/watch?v=41_TNGDDnfQ).
## Related Links
- [OpenClaw Subagent Docs](https://github.com/openclaw/openclaw)
- [Discord Bot Setup](https://discord.com/developers/docs)

67
openclaw/usecases/custom-morning-brief.md Normal file
View File

@@ -0,0 +1,67 @@
# Custom Morning Brief
You wake up and spend the first 30 minutes of your day catching up — scrolling news, checking your calendar, reviewing your to-do list, trying to figure out what matters today. What if all of that was already done and waiting for you as a text message?
This workflow has OpenClaw send you a fully customized morning briefing every day at a scheduled time, covering news, tasks, ideas, and proactive recommendations.
## What It Does
- Sends a structured morning report to Telegram, Discord, or iMessage at the same time every day (e.g., 8:00 AM)
- Researches overnight news relevant to your interests by browsing the web
- Reviews your to-do list and surfaces tasks for the day
- Generates creative output (full scripts, email drafts, business proposals — not just ideas) while you sleep
- Recommends tasks the AI can complete autonomously to help you that day
## Pain Point
You're spending your most productive morning hours just getting oriented. Meanwhile, your AI agent sits idle all night. The morning brief turns idle overnight hours into productive prep time — you wake up to work already done.
## Skills You Need
- Telegram, Discord, or iMessage integration
- Todoist / Apple Reminders / Asana integration (whichever you use for tasks)
- [x-research-v2](https://clawhub.ai) for social media trend research (optional)
## How to Set It Up
1. Connect OpenClaw to your messaging platform and task manager.
2. Prompt OpenClaw:
```text
I want to set up a regular morning brief. Every morning at 8:00 AM,
send me a report through Telegram.
I want this report to include:
1. News stories relevant to my interests (AI, startups, tech)
2. Ideas for content I can create today
3. Tasks I need to complete today (pull from my to-do list)
4. Recommendations for tasks you can complete for me today
For the content ideas, write full draft scripts/outlines — not just titles.
```
3. OpenClaw will schedule this automatically. Verify it's working by checking your messages the next morning.
4. Customize over time — just text your bot:
```text
Add weather forecast to my morning brief.
Stop including general news, focus only on AI.
Include a motivational quote each morning.
```
5. If you can't think of what to include, you don't have to — just say:
```text
I want this report to include things relevant to me.
Think of what would be most helpful to put in this report.
```
## Key Insights
- The AI-recommended tasks section is the most powerful part — it has the agent proactively think of ways to help you, rather than waiting for instructions.
- You can customize the brief just by texting. Say "Add stock prices to my morning brief" and it updates.
- Full drafts (not just ideas) are the key to saving time. Wake up to scripts, not suggestions.
- It doesn't matter what industry you're in — a morning brief with tasks, news, and proactive suggestions is universally useful.
## Based On
Inspired by [Alex Finn's video on life-changing OpenClaw use cases](https://www.youtube.com/watch?v=41_TNGDDnfQ).

23
openclaw/usecases/daily-reddit-digest.md Normal file
View File

@@ -0,0 +1,23 @@
# Daily Reddit Digest
Run a daily digest everyday to give you the top performing posts from your favourite subreddits.
What to use it for:
• Browsing subreddits (hot/new/top posts)
• Searching posts by topic
• Pulling comment threads for context
• Building shortlists of posts to manually review/reply to later
> It's read-only. No posting, voting, or commenting.
## Skills you Need
[reddit-readonly](https://clawhub.ai/buksan1950/reddit-readonly) skill. It doesn't need auth.
## How to Set it Up
After installing the skill, prompt your OpenClaw:
```text
I want you to give me the top performing posts from the following subreddits.
<paste the list here>
Create a separate memory for the reddit processes, about the type of posts I like to see and every day ask me if I liked the list you provided. Save my preference as rules in the memory to use for a better digest curation. (e.g. do not include memes.)
Every day at 5pm, run this process and give me the digest.
```

96
openclaw/usecases/daily-youtube-digest.md Normal file
View File

@@ -0,0 +1,96 @@
# Daily YouTube Digest
Start your day with a personalized summary of new videos from your favorite YouTube channels — no more missing content from creators you actually want to follow.
## Pain Point
YouTube notifications are unreliable. You subscribe to channels, but their new videos never show up in your home feed. They're not in notifications. They just... disappear. This doesn't mean you don't want to see them — it means YouTube's algorithm buried them.
Plus: it's fun to start the day with curated content insights instead of doom-scrolling a recommendation feed.
## What It Does
- Fetches the latest videos from a list of your favorite channels
- Summarizes or extracts key insights from each video's transcript
- Delivers a digest to you daily (or on demand)
## Skills You Need
Install the [youtube-full](https://clawhub.ai/therohitdas/youtube-full) skill.
Just tell your OpenClaw:
```text
"Install the youtube-full skill and set it up for me"
```
or
```bash
npx clawhub@latest install youtube-full
```
That's it. The agent handles the rest — including account creation and API key setup. You get **100 free credits on signup**, no credit card required.
> Note: After creating the account, the skill auto-stores the API key securely in correct locations based on the OS, so the API will work in all contexts.
![youtube-full skill installation](https://pub-15904f15a44a4ea69350737e87660b92.r2.dev/media/1770620159490-e41e7baa.png)
### Why TranscriptAPI.com over yt-dlp?
| CLI tools (yt-dlp, etc.) | TranscriptAPI |
|--------------------------|---------------|
| Verbose logs flood agent context | Clean JSON responses |
| Doesn't work on GCP/cloud OpenClaw | Works everywhere, fast |
| Gets blocked randomly by YouTube | Powers [YouTubeToTranscript.com](https://youtubetotranscript.com) serving millions. Cached and reliable. |
| Requires binary installation | No binaries, just HTTP |
## How to Set It Up
### Option 1: Channel-based digest
Prompt OpenClaw:
```text
Every morning at 8am, fetch the latest videos from these YouTube channels and give me a digest with key insights from each:
- @TED
- @Fireship
- @ThePrimeTimeagen
- @lexfridman
For each new video (uploaded in the last 24-48 hours):
1. Get the transcript
2. Summarize the main points in 2-3 bullets
3. Include the video title, channel name, and link
If a channel handle doesn't resolve, search for it and find the correct one.
Save my channel list to memory so I can add/remove channels later.
```
### Option 2: Keyword-based digest
Track new videos about a specific topic:
```text
Every day, search YouTube for new videos about "OpenClaw" (or "Claude Code", "AI agents", etc).
Maintain a file called seen-videos.txt with video IDs you've already processed.
Only fetch transcripts for videos NOT in that file.
After processing, add the video ID to seen-videos.txt.
For each new video:
1. Get the transcript
2. Give me a 3-bullet summary
3. Note anything relevant to my work
Run this every morning at 9am.
```
This way you never waste credits re-fetching videos you've already seen.
## Tips
- `channel/latest` and `channel/resolve` are **free** (0 credits) — checking for new uploads costs nothing
- Only transcripts cost 1 credit each
- Ask for different digest styles: key takeaways, notable quotes, timestamps of interesting moments
- This already exists as a product - [Recapio - Daily YouTube Recap](https://recapio.com/features/daily-recaps)

113
openclaw/usecases/dynamic-dashboard.md Normal file
View File

@@ -0,0 +1,113 @@
# Dynamic Dashboard with Sub-agent Spawning
Static dashboards show stale data and require constant manual updates. You want real-time visibility across multiple data sources without building a custom frontend or hitting API rate limits.
This workflow creates a live dashboard that spawns sub-agents to fetch and process data in parallel:
• Monitors multiple data sources simultaneously (APIs, databases, GitHub, social media)
• Spawns sub-agents for each data source to avoid blocking and distribute API load
• Aggregates results into a unified dashboard (text, HTML, or Canvas)
• Updates every N minutes with fresh data
• Sends alerts when metrics cross thresholds
• Maintains historical trends in a database for visualization
## Pain Point
Building a custom dashboard takes weeks. By the time it's done, requirements have changed. Polling multiple APIs sequentially is slow and hits rate limits. You need insight now, not after a weekend of coding.
## What It Does
You define what you want to monitor conversationally: "Track GitHub stars, Twitter mentions, Polymarket volume, and system health." OpenClaw spawns sub-agents to fetch each data source in parallel, aggregates the results, and delivers a formatted dashboard to Discord or as an HTML file. Updates run automatically on a cron schedule.
Example dashboard sections:
- **GitHub**: stars, forks, open issues, recent commits
- **Social Media**: Twitter mentions, Reddit discussions, Discord activity
- **Markets**: Polymarket volume, prediction trends
- **System Health**: CPU, memory, disk usage, service status
## Skills Needed
- Sub-agent spawning for parallel execution
- `github` (gh CLI) for GitHub metrics
- `bird` (Twitter) for social data
- `web_search` or `web_fetch` for external APIs
- `postgres` for storing historical metrics
- Discord or Canvas for rendering the dashboard
- Cron jobs for scheduled updates
## How to Set it Up
1. Set up a metrics database:
```sql
CREATE TABLE metrics (
id SERIAL PRIMARY KEY,
source TEXT, -- e.g., "github", "twitter", "polymarket"
metric_name TEXT,
metric_value NUMERIC,
timestamp TIMESTAMPTZ DEFAULT NOW()
);
CREATE TABLE alerts (
id SERIAL PRIMARY KEY,
source TEXT,
condition TEXT,
threshold NUMERIC,
last_triggered TIMESTAMPTZ
);
```
2. Create a Discord channel for dashboard updates (e.g., #dashboard).
3. Prompt OpenClaw:
```text
You are my dynamic dashboard manager. Every 15 minutes, run a cron job to:
1. Spawn sub-agents in parallel to fetch data from:
- GitHub: stars, forks, open issues, commits (past 24h)
- Twitter: mentions of "@username", sentiment analysis
- Polymarket: volume for tracked markets
- System: CPU, memory, disk usage via shell commands
2. Each sub-agent writes results to the metrics database.
3. Aggregate all results and format a dashboard:
📊 **Dashboard Update** — [timestamp]
**GitHub**
- ⭐ Stars: [count] (+[change])
- 🍴 Forks: [count]
- 🐛 Open Issues: [count]
- 💻 Commits (24h): [count]
**Social Media**
- 🐦 Twitter Mentions: [count]
- 📈 Sentiment: [positive/negative/neutral]
**Markets**
- 📊 Polymarket Volume: $[amount]
- 🔥 Trending: [market names]
**System Health**
- 💻 CPU: [usage]%
- 🧠 Memory: [usage]%
- 💾 Disk: [usage]%
4. Post to Discord #dashboard.
5. Check alert conditions:
- If GitHub stars change > 50 in 1 hour → ping me
- If system CPU > 90% → alert
- If negative sentiment spike on Twitter → notify
Store all metrics in the database for historical analysis.
```
4. Optional: Use Canvas to render an HTML dashboard with charts and graphs.
5. Query historical data: "Show me GitHub star growth over the past 30 days."
## Related Links
- [Parallel Processing with Sub-agents](https://docs.openclaw.ai/subagents)
- [Dashboard Design Principles](https://www.nngroup.com/articles/dashboard-design/)

35
openclaw/usecases/earnings-tracker.md Normal file
View File

@@ -0,0 +1,35 @@
# AI-Powered Earnings Tracker
Following earnings season across dozens of tech companies means checking multiple sources and remembering report dates. You want to stay on top of AI/tech earnings without manually tracking every company.
This workflow automates earnings tracking and delivery:
• Weekly Sunday preview: scans the upcoming earnings calendar and posts relevant tech/AI companies to Telegram
• You pick which companies you care about, and OpenClaw schedules one-shot cron jobs for each earnings date
• After each report drops, OpenClaw searches for results, formats a detailed summary (beat/miss, key metrics, AI highlights), and delivers it
## Skills you Need
- `web_search` (built-in)
- Cron job support in OpenClaw
- Telegram topic for earnings updates
## How to Set it Up
1. Create a Telegram topic called "earnings" for updates.
2. Prompt OpenClaw:
```text
Every Sunday at 6 PM, run a cron job to:
1. Search for the upcoming week's earnings calendar for tech and AI companies
2. Filter for companies I care about (NVDA, MSFT, GOOGL, META, AMZN, TSLA, AMD, etc.)
3. Post the list to my Telegram "earnings" topic
4. Wait for me to confirm which ones I want to track
When I reply with which companies to track:
1. Schedule one-shot cron jobs for each earnings date/time
2. After each report drops, search for earnings results
3. Format a summary including: beat/miss, revenue, EPS, key metrics, AI-related highlights, guidance
4. Post to Telegram "earnings" topic
Keep a memory of which companies I typically track so you can auto-suggest them each week.
```

88
openclaw/usecases/event-guest-confirmation.md Normal file
View File

@@ -0,0 +1,88 @@
# Event Guest Confirmation
You're hosting an event — a dinner party, a wedding, a company offsite — and you need to confirm attendance from a list of guests. Manually calling 20+ people is tedious: you play phone tag, forget who said what, and lose track of dietary restrictions or plus-ones. Texting works sometimes, but people ignore messages. A real phone call gets a much higher response rate.
This use case has OpenClaw call each guest on your list using the [SuperCall](https://clawhub.ai/xonder/supercall) plugin, confirm whether they're attending, collect any notes, and compile everything into a summary for you.
## What It Does
- Iterates through a guest list (names + phone numbers) and calls each one
- The AI introduces itself as your event coordinator with a friendly persona
- Confirms the event date, time, and location with the guest
- Asks if they're attending, and collects any notes (dietary needs, plus-ones, arrival time, etc.)
- After all calls are complete, compiles a summary: who confirmed, who declined, who didn't pick up, and any notes
## Why SuperCall
This use case works with the [SuperCall](https://clawhub.ai/xonder/supercall) plugin specifically — not the built-in `voice_call` plugin. The key difference: SuperCall is a fully standalone voice agent. The AI persona on the call **only has access to the context you provide** (the persona name, the goal, and the opening line). It cannot access your gateway agent, your files, your other tools, or anything else.
This matters for guest confirmation because:
- **Safety**: The person on the other end of the call can't manipulate or access your agent through the conversation. There's no risk of prompt injection or data leakage.
- **Better conversations**: Because the AI is scoped to a single focused task (confirm attendance), it stays on-topic and handles the call more naturally than a general-purpose voice agent would.
- **Batch-friendly**: You're making many calls to different people. A sandboxed persona that resets per call is exactly what you want — no bleed-over between conversations.
## Skills You Need
- [SuperCall](https://clawhub.ai/xonder/supercall) — install via `openclaw plugins install @xonder/supercall`
- A Twilio account with a phone number (for making outbound calls)
- An OpenAI API key (for the GPT-4o Realtime voice AI)
- ngrok (for webhook tunneling — free tier works)
See the [SuperCall README](https://github.com/xonder/supercall) for full configuration instructions.
## How to Set It Up
1. Install and configure SuperCall following the [setup guide](https://github.com/xonder/supercall#configuration). Make sure hooks are enabled in your OpenClaw config.
2. Prepare your guest list. You can paste it directly in chat or keep it in a file:
```text
Guest List — Summer BBQ, Saturday June 14th, 4 PM, 23 Oak Street
- Sarah Johnson: +15551234567
- Mike Chen: +15559876543
- Rachel Torres: +15555551234
- David Kim: +15558887777
```
3. Prompt OpenClaw:
```text
I need you to confirm attendance for my event. Here are the details:
Event: Summer BBQ
Date: Saturday, June 14th at 4 PM
Location: 23 Oak Street
Here is my guest list:
<paste your guest list here>
For each guest, use supercall to call them. Use the persona "Jamie, event coordinator
for [your name]". The goal for each call is to confirm whether they're attending,
and note any dietary restrictions, plus-ones, or other comments.
After each call, log the result. Once all calls are done, give me a full summary:
- Who confirmed
- Who declined
- Who didn't answer
- Any notes or special requests from each guest
```
4. OpenClaw will call each guest one by one using SuperCall, then compile the results. You can check in on progress at any time by asking for a status update.
## Key Insights
- **Start with a small test**: Try it with 2-3 guests first to make sure the persona and opening line sound right. You can adjust the tone before calling the full list.
- **Be mindful of calling hours**: Don't schedule calls too early or too late. You can tell OpenClaw to only call between certain hours.
- **Review transcripts**: SuperCall logs transcripts to `~/clawd/supercall-logs`. Skim through them after the first batch to see how conversations went.
- **No-answer handling**: If someone doesn't pick up, OpenClaw can note it and you can decide whether to retry later or follow up by text.
- **Real phone calls cost money**: Each call uses Twilio minutes. Set appropriate limits in your Twilio account, especially for large guest lists.
## Related Links
- [SuperCall on ClawHub](https://clawhub.ai/xonder/supercall)
- [SuperCall on GitHub](https://github.com/xonder/supercall)
- [Twilio Console](https://console.twilio.com)
- [OpenAI Realtime API](https://platform.openai.com/docs/guides/realtime)
- [ngrok](https://ngrok.com)

123
openclaw/usecases/family-calendar-household-assistant.md Normal file
View File

@@ -0,0 +1,123 @@
# Family Calendar Aggregation & Household Assistant
Modern families juggle five or more calendars — work, personal, shared family, kids' school, extracurriculars — across different platforms and formats. Important events slip through the cracks because no single view exists. Meanwhile, household coordination (grocery lists, pantry inventory, appointment scheduling) happens through scattered text messages that get buried.
This use case turns OpenClaw into an always-on household coordinator: aggregating calendars into a morning briefing, monitoring messages for actionable items, and managing household logistics through a shared chat interface.
## Pain Point
- **Calendar fragmentation**: Work calendars have security restrictions preventing sharing. School calendars arrive as PDFs or hand-written websites. Camp schedules live in emails. Manually checking each one every morning is unsustainable — and "copying events across calendars works well until I forget and one slips through the cracks."
- **Household coordination overhead**: "How much milk do we have?" requires physically checking the fridge, then the basement pantry, then texting back. Multiply this across a week's worth of grocery runs.
- **Missed appointments**: Appointment confirmations arrive via text message and sit there unacted upon — no calendar event, no driving time buffer, no reminder.
## What It Does
- **Morning briefing**: Aggregates all family calendars into a single daily summary delivered via your preferred channel
- **Ambient message monitoring**: Watches iMessage/text conversations and automatically creates calendar events when it detects appointments (dentist confirmations, meeting plans, etc.)
- **Driving time buffers**: Adds travel time blocks before and after detected appointments
- **Household inventory**: Maintains a running inventory of pantry/fridge items that either partner can query from anywhere
- **Grocery coordination**: Deduplicates ingredients across recipes, tracks what's running low, and generates shopping lists
- **Photo-based input**: Snap a photo of a school calendar or freezer contents and the agent processes it into structured data
## Skills You Need
- Calendar API access (Google Calendar, Apple Calendar via `ical`)
- `imessage` skill for message monitoring (macOS only)
- Telegram or Slack for the shared family chat interface
- File system access for inventory tracking
- Camera/photo processing for OCR of physical calendars
## How to Set It Up
### 1. Calendar Aggregation
Configure OpenClaw to pull from all family calendar sources:
```text
## Calendar Sources
On morning briefing (8:00 AM):
1. Fetch my Google Work Calendar (read-only OAuth)
2. Fetch shared Family Google Calendar
3. Fetch partner's calendar (shared view)
4. Check ~/Documents/school-calendars/ for any new PDFs → OCR and extract events
5. Check recent emails for calendar attachments or event invitations
Compile into a single briefing:
- Today's events (all calendars, color-coded by source)
- Upcoming 3-day lookahead for conflicts
- Any new events added since yesterday
- Weather context for outdoor events
Deliver via Telegram/Slack family channel.
```
### 2. Ambient Message Monitoring
This is the key differentiator — the agent watches passively and acts when it recognizes something actionable:
```text
## Message Monitoring (HEARTBEAT.md)
Every 15 minutes:
1. Check new iMessages across all conversations
2. Detect appointment-like patterns:
- "Your appointment is confirmed for..."
- "Can we meet on [date] at [time]?"
- "Practice moved to Saturday at 3pm"
3. When detected:
- Create calendar event with details
- Add 30-minute driving buffer before AND after
- Send confirmation to family Telegram: "Created: Dentist appointment, Tue 2pm. Added drive time 1:30-2:00 and 3:00-3:30."
- If relevant to partner, add invite
4. Detect promise/commitment patterns:
- "I'll send that over by Friday"
- "Let's do dinner next week"
→ Create calendar hold or reminder
```
### 3. Household Inventory
```text
## Pantry Tracking
Maintain ~/household/inventory.json with:
- Item name, quantity, location (fridge/pantry/basement)
- Last updated timestamp
- Low-stock threshold
Update methods:
- Photo: User sends photo of fridge/pantry → vision model extracts items
- Text: "We're out of eggs" / "Bought 2 gallons of milk"
- Receipt: Photo of grocery receipt → update inventory
Query: Either partner can ask via Telegram:
- "Do we have butter?" → Check inventory, respond with location and quantity
- "What's running low?" → List items below threshold
- "Generate grocery list" → Compile low-stock items + any recipe ingredients needed
```
## Key Insights
- **Ambient > active**: The biggest unlock is the agent acting without being asked. Detecting an appointment in a text message and creating a calendar event with driving buffers — "I didn't ask it to do that. It just knew that's what I'd want."
- **Mac Mini is the sweet spot**: This use case benefits heavily from running on a home Mac Mini — iMessage integration, Apple Calendar, and always-on availability
- **Start read-only**: Begin with calendar reading and message monitoring before enabling write actions (creating events, sending messages)
- **Shared Telegram channel**: Gives both partners visibility into what the agent is doing — builds trust and catches errors early
- **Photo input is underrated**: Snapping a photo of a school calendar PDF or freezer contents is faster than typing — and the vision model handles it well
## Inspired By
This use case combines several community patterns:
- **Calendar aggregation**: Described by HN user `angiolillo` in [a Hacker News discussion](https://news.ycombinator.com/item?id=46872465), who detailed the pain of checking work, personal, family, and kids' school calendars separately each morning.
- **Ambient message monitoring**: Documented by [Sparkry AI](https://sparkryai.substack.com/p/24-hours-with-openclaw-the-ai-setup) — when a wife received a dental appointment text, OpenClaw automatically created a calendar event with 30-minute driving buffers, without being asked. Also confirmed on the [OpenClaw Showcase](https://openclaw.ai/showcase) where `@theaaron` called chat-based calendar management "one of the best uses of an LLM I've ever experienced."
- **Household coordination**: Brandon Wang's [Clawdbot "Linguini"](https://brandon.wang/2026/clawdbot) running on a Mac Mini at home — handling text message follow-ups, creating calendar events from photos, tracking Airbnb prices, processing freezer inventory photos, and coordinating household logistics via iMessage and Slack.
- **Pantry tracking**: Multiple HN users discussed the value (and challenge) of maintaining household inventory, with `dns_snek` noting: "I forget where I put things down 5 seconds ago... It's genuinely a big problem for me because I let things expire."
## Related Links
- [OpenClaw iMessage Skill](https://github.com/openclaw/openclaw)
- [Google Calendar API](https://developers.google.com/calendar)
- [Apple Calendar (EventKit)](https://developer.apple.com/documentation/eventkit)
- [OpenClaw Showcase — Calendar Testimonials](https://openclaw.ai/showcase)

84
openclaw/usecases/habit-tracker-accountability-coach.md Normal file
View File

@@ -0,0 +1,84 @@
# Habit Tracker & Accountability Coach
You've tried every habit tracker app out there. They all work for a week, then you stop opening them. The problem isn't the app — it's that tracking habits is passive. What if your agent actively reached out to you, asked how your day went, and adapted its approach based on whether you're on a streak or falling off?
This use case turns OpenClaw into a proactive accountability partner that checks in with you daily via Telegram or SMS.
## Pain Point
Habit apps rely on you remembering to open them. Push notifications are easy to ignore. What actually works for behavior change is **active accountability** — someone (or something) that asks you directly, celebrates your wins, and nudges you when you slip. This agent does exactly that, without the awkwardness of bugging a friend.
## What It Does
- **Daily check-ins** via Telegram or SMS at times you choose (e.g., 7 AM for morning routine, 9 PM for end-of-day review)
- **Tracks habits** you define — exercise, reading, meditation, water intake, coding, whatever matters to you
- **Streak tracking** — knows your current streak for each habit and references it in messages
- **Adaptive nudges** — adjusts tone based on your performance (encouraging when you're consistent, gently persistent when you miss days)
- **Weekly reports** — summarizes your week with completion rates, longest streaks, and patterns (e.g., "You tend to skip workouts on Wednesdays")
## Skills You Need
- Telegram or SMS integration (Twilio for SMS, or Telegram Bot API)
- Scheduling / cron for timed check-ins
- File system or database access for storing habit data
- Optional: Google Sheets integration for a visual habit dashboard
## How to Set It Up
1. Define your habits and check-in schedule:
```text
I want you to be my accountability coach. Track these daily habits for me:
1. Morning workout (check in at 7:30 AM)
2. Read for 30 minutes (check in at 8:00 PM)
3. No social media before noon (check in at 12:30 PM)
4. Drink 8 glasses of water (check in at 6:00 PM)
Send me a Telegram message at each check-in time asking if I completed
the habit. Keep track of my streaks in a local file.
```
2. Set up the tracking and tone:
```text
When I confirm a habit, respond with a short encouraging message and
mention my current streak. Example: "Day 12 of morning workouts. Solid."
When I miss a habit, don't guilt-trip me. Just acknowledge it and remind
me why I started. If I miss 3 days in a row, send a longer motivational
message and ask if I want to adjust the goal.
If I don't respond to a check-in within 2 hours, send one follow-up.
Don't spam me after that.
```
3. Add weekly reports:
```text
Every Sunday at 10 AM, send me a weekly summary:
- Completion rate for each habit
- Current streaks
- Best day and worst day
- One pattern you noticed (e.g., "You always skip reading on Fridays")
- One suggestion for next week
Store all data in ~/habits/log.json so I can review history anytime.
```
4. Optional — visual dashboard via Google Sheets:
```text
At the end of each day, update a Google Sheet with today's habit data.
Columns: Date, Workout, Reading, No Social Media, Water, Notes.
Mark completed habits with ✓ and missed with ✗.
```
## Key Insights
- The **adaptive tone** is what makes this different from a cron job. A static reminder gets ignored. A message that says "Day 15, don't break it now" actually motivates.
- Keep the number of tracked habits small (3-5). Tracking too many leads to check-in fatigue and you'll start ignoring the messages.
- The weekly pattern analysis is surprisingly useful — you'll discover things like "I never exercise on days I have early meetings" and can plan around it.
- Pairs well with the [Health & Symptom Tracker](health-symptom-tracker.md) if you want to correlate habits with how you feel.
## Related Links
- [Telegram Bot API](https://core.telegram.org/bots/api)
- [Twilio SMS API](https://www.twilio.com/docs/sms)
- [Google Sheets API](https://developers.google.com/sheets/api)

41
openclaw/usecases/health-symptom-tracker.md Normal file
View File

@@ -0,0 +1,41 @@
# Health & Symptom Tracker
Identifying food sensitivities requires consistent logging over time, which is tedious to maintain. You need reminders to log and analysis to spot patterns.
This workflow tracks food and symptoms automatically:
• Message your food and symptoms in a dedicated Telegram topic and OpenClaw logs everything with timestamps
• 3x daily reminders (morning, midday, evening) prompt you to log meals
• Over time, analyzes patterns to identify potential triggers
## Skills you Need
- Cron jobs for reminders
- Telegram topic for logging
- File storage (markdown log file)
## How to Set it Up
1. Create a Telegram topic called "health-tracker" (or similar).
2. Create a log file: `~/clawd/memory/health-log.md`
3. Prompt OpenClaw:
```text
When I message in the "health-tracker" topic:
1. Parse the message for food items and symptoms
2. Log to ~/clawd/memory/health-log.md with timestamp
3. Confirm what was logged
Set up 3 daily reminders:
- 8 AM: "🍳 Log your breakfast"
- 1 PM: "🥗 Log your lunch"
- 7 PM: "🍽️ Log your dinner and any symptoms"
Every Sunday, analyze the past week's log and identify patterns:
- Which foods correlate with symptoms?
- Are there time-of-day patterns?
- Any clear triggers?
Post the analysis to the health-tracker topic.
```
4. Optional: Add a memory file for OpenClaw to track known triggers and update it as patterns emerge.

15
openclaw/usecases/inbox-declutter.md Normal file
View File

@@ -0,0 +1,15 @@
# Inbox De-clutter
Newsletters can take up the inbox like nothing else. Often times they pile-up without being opened at all.
## Skills you Need
[Gmail OAuth Setup](https://clawhub.ai/kai-jar/gmail-oauth).
## How to Set it Up
1. [optional] Create a new gmail specifically for OpenClaw.
2. [optional] Unsubscribe from all newsletters from your main email and subscribe to them using the OpenClaw email.
3. Install the skill and make sure it works.
4. Instruct OpenClaw:
```txt
I want you to run a cron job everyday at 8 p.m. to read all the newsletter emails of the past 24 hours and give me a digest of the most important bits along with links to read more. Then ask for my feedback on whether you picked good bits, and update your memory based on my preferences for better digests in the future jobs.
```

36
openclaw/usecases/knowledge-base-rag.md Normal file
View File

@@ -0,0 +1,36 @@
# Personal Knowledge Base (RAG)
You read articles, tweets, and watch videos all day but can never find that one thing you saw last week. Bookmarks pile up and become useless.
This workflow builds a searchable knowledge base from everything you save:
• Drop any URL into Telegram or Slack and it auto-ingests the content (articles, tweets, YouTube transcripts, PDFs)
• Semantic search over everything you've saved: "What did I save about agent memory?" returns ranked results with sources
• Feeds into other workflows — e.g., the video idea pipeline queries the KB for relevant saved content when building research cards
## Skills you Need
- [knowledge-base](https://clawhub.ai) skill (or build custom RAG with embeddings)
- `web_fetch` (built-in)
- Telegram topic or Slack channel for ingestion
## How to Set it Up
1. Install the knowledge-base skill from ClawdHub.
2. Create a Telegram topic called "knowledge-base" (or use a Slack channel).
3. Prompt OpenClaw:
```text
When I drop a URL in the "knowledge-base" topic:
1. Fetch the content (article, tweet, YouTube transcript, PDF)
2. Ingest it into the knowledge base with metadata (title, URL, date, type)
3. Reply with confirmation: what was ingested and chunk count
When I ask a question in this topic:
1. Search the knowledge base semantically
2. Return top results with sources and relevant excerpts
3. If no good matches, tell me
Also: when other workflows need research (e.g., video ideas, meeting prep), automatically query the knowledge base for relevant saved content.
```
4. Test it by dropping a few URLs and asking questions like "What do I have about LLM memory?"

40
openclaw/usecases/latex-paper-writing.md Normal file
View File

@@ -0,0 +1,40 @@
# LaTeX Paper Writing
Setting up a local LaTeX environment is painful — installing TeX Live takes gigabytes, debugging compilation errors is tedious, and switching between your editor and PDF viewer breaks flow. You want to write and compile LaTeX papers conversationally without any local setup.
This workflow turns your agent into a LaTeX writing assistant with instant compilation:
- Write LaTeX collaboratively with the agent — describe what you want and it generates the source
- Compile to PDF instantly with pdflatex, xelatex, or lualatex (no local TeX installation needed)
- Preview PDFs inline without switching to another app
- Use starter templates (article, IEEE, beamer, Chinese article) to skip boilerplate
- Bibliography support with BibTeX/BibLaTeX — just paste your .bib content
## Skills you Need
- [latex-compiler](https://github.com/Prismer-AI/Prismer/tree/main/skills/latex-compiler) skill (4 tools: `latex_compile`, `latex_preview`, `latex_templates`, `latex_get_template`)
- Prismer workspace container (runs the LaTeX server on port 8080 with full TeX Live)
## How to Set it Up
1. Clone and deploy [Prismer](https://github.com/Prismer-AI/Prismer) with Docker (the LaTeX server with full TeX Live starts automatically):
```bash
git clone https://github.com/Prismer-AI/Prismer.git && cd Prismer
docker compose -f docker/docker-compose.dev.yml up
```
2. The `latex-compiler` skill is built-in — no installation needed. Prompt OpenClaw:
```text
Help me write a research paper in LaTeX. Here's my workflow:
1. Start from the IEEE template (or article/beamer depending on what I need)
2. When I describe a section, generate the LaTeX source for it
3. After each major edit, compile and preview the PDF so I can check formatting
4. If there are compilation errors, read the log and fix them automatically
5. When I provide BibTeX entries, add them to the bibliography and recompile
Use xelatex if I need Chinese/CJK support, otherwise default to pdflatex.
Always run 2 passes for cross-references.
```
3. Try it: "Start a new IEEE paper titled 'A Survey of LLM Agents'. Give me the template with abstract and introduction sections filled in, then compile it."

79
openclaw/usecases/local-crm-framework.md Normal file
View File

@@ -0,0 +1,79 @@
# Local CRM Framework with DenchClaw
Setting up a CRM that actually works with OpenClaw is painful. You need to wire up databases, build UIs, configure browser automation, connect messaging platforms, and somehow get the agent to understand your data schema. Most people give up halfway through and end up with a half-working Notion integration.
DenchClaw is an open-source framework that turns OpenClaw into a fully local CRM, sales automation, and productivity platform — installed with a single command and running entirely on your machine.
## Pain Point
OpenClaw is incredibly powerful as a primitive, but using it for real business workflows (lead tracking, outbound, pipeline management) requires stitching together a dozen tools: a database, a UI, browser access, messaging integrations, file management. Every new integration means more manual setup, more credentials to manage, and more things that break. You want Cursor-level UX for your business operations, not a pile of shell scripts.
## What It Does
- **One-command setup**: `npx denchclaw` installs everything — DuckDB database, web UI, OpenClaw profile, browser automation, skills — and opens at `localhost:3100`
- **Natural language CRM**: Ask "show me companies with more than 5 employees" and it updates the view live. No manual filters needed
- **Full browser automation**: Copies your Chrome profile so the agent has your same auth state — say "import everything from my HubSpot" and it logs in, exports, and imports
- **Multiple views**: Table, Kanban, Calendar, Timeline (Gantt), Gallery, and List views — all configurable by the agent via YAML
- **App builder**: OpenClaw builds self-contained web apps (dashboards, tools, games) that run inside the workspace with access to your data
- **File-system-first**: Table filters, views, column toggles, calendar settings — everything is a file, so OpenClaw can directly read and modify it
- **Works as a coding agent**: DenchClaw built DenchClaw. It's also a full file tree browser and code editor for your Mac
## How to Set It Up
1. Install with one command:
```bash
npx denchclaw
```
2. Complete the onboarding wizard. DenchClaw creates a dedicated OpenClaw profile called `dench` and starts a gateway on port 19001.
3. Open `localhost:3100` in your browser. On Safari, add it to your Dock as a PWA.
4. Start talking to it:
```text
Hey, create a "Leads" object with fields: Name, Email, Company, Status (New/Contacted/Qualified/Won/Lost), and Notes. Import this CSV of leads I downloaded from Apollo.
```
```text
Show me all leads where Status is "Contacted" and sort by last updated. Switch to Kanban view grouped by Status.
```
```text
Go to my LinkedIn, find the last 20 people who viewed my profile, and add them as leads with their company info enriched.
```
```text
Draft a personalized outreach email to each lead in "New" status based on their company's recent news. Save the drafts in a new "Outreach Drafts" document.
```
5. You can also use it from Telegram or any connected messaging platform — manage your pipeline from your phone while on the go.
## Skills Needed
DenchClaw bundles all required skills automatically:
- **CRM Skill** — DuckDB-backed structured data management with objects, fields, entries, and multiple view types
- **App Builder Skill** — Build web apps (dashboards, tools) that run inside the workspace with access to your database
- **Browser Automation Skill** — Chromium browser with your existing Chrome auth state for web scraping, imports, and outreach
No additional skill installation or configuration required.
## Key Insights
- **File-system = agent-native UI**: Because every setting, filter, and view is stored as a YAML/markdown file, OpenClaw can modify the UI as naturally as it edits code. No API wrappers needed.
- **DuckDB is the sweet spot**: Smallest, most performant embedded database that still supports full SQL. No server process, no credentials, no network — just a file.
- **Chrome profile cloning is a superpower**: Instead of fighting OAuth flows and API rate limits, DenchClaw copies your browser's auth state. The agent sees what you see, does what you do.
- **One `npx` command beats a weekend of setup**: The entire stack (database, web UI, OpenClaw profile, gateway, browser, skills) installs and configures itself. No Docker, no env files, no dependency hell.
## Demo
[Watch the demo video](https://www.youtube.com/watch?v=pfACTbc3Bh4#t=43) — shows the full workflow from install to managing a live CRM pipeline with natural language.
## Related Links
- [DenchClaw GitHub](https://github.com/DenchHQ/DenchClaw) — MIT licensed, open source
- [DenchClaw Website](https://denchclaw.com)
- [Discord Community](https://discord.gg/PDFXNVQj9n)
- [Skills Store](https://skills.sh)

84
openclaw/usecases/market-research-product-factory.md Normal file
View File

@@ -0,0 +1,84 @@
# Market Research & Product Factory
You want to build a product but don't know what to build. Or you have a business and need to understand what your customers are struggling with. This workflow uses the Last 30 Days skill to mine Reddit and X for real pain points, then has OpenClaw build solutions to those problems.
## What It Does
- Researches any topic across Reddit and X over the last 30 days using the [Last 30 Days](https://github.com/mvanhorn/last30days-skill/) skill
- Surfaces real challenges, complaints, and feature requests people are posting about
- Helps you identify product opportunities from genuine user pain points
- Takes it a step further: ask OpenClaw to build an MVP that solves one of those challenges
- Creates a full research-to-product pipeline with zero coding on your part
## Pain Point
Most aspiring entrepreneurs struggle with the "what to build" problem. Market research traditionally means hours of manual browsing through forums, social media, and review sites. This automates the entire discovery-to-prototype pipeline.
## Skills You Need
- [Last 30 Days](https://github.com/mvanhorn/last30days-skill/) skill by Matt Van Horde
- Telegram or Discord integration for receiving research reports
## How to Set It Up
1. Install the Last 30 Days skill:
```text
Install this skill: https://github.com/mvanhorn/last30days-skill/
```
2. Run research on any topic:
```text
Please use the Last 30 Days skill to research challenges people are
having with [your topic here].
Organize the findings into:
- Top pain points (ranked by frequency)
- Specific complaints and feature requests
- Gaps in existing solutions
- Opportunities for a new product
```
3. Pick a pain point and have OpenClaw build a solution:
```text
Build me an MVP that solves [pain point from research].
Keep it simple — just the core functionality.
Ship it as a web app I can share with people.
```
4. For ongoing market intelligence, schedule regular research:
```text
Every Monday morning, use the Last 30 Days skill to research what
people are saying about [your niche] on Reddit and X. Summarize the
top opportunities and send them to my Telegram.
```
## Real World Example
```text
"Use the Last 30 Days skill to research challenges people are having with OpenClaw."
Results:
- Setup difficulty: Many users struggle with initial configuration
- Skill discovery: People can't find skills that do what they need
- Cost concerns: Users want cheaper model alternatives
→ "Build me a simple web app that makes OpenClaw setup easier with a guided wizard."
OpenClaw builds the app. You ship it. You have a product.
```
## Key Insights
- This is **entrepreneurship on autopilot**: find problems → validate demand → build solutions, all through text messages.
- The Last 30 Days skill gives you real, unfiltered user sentiment — not sanitized survey data.
- You don't need to be technical. OpenClaw does the research AND the building.
- Schedule weekly research to stay on top of evolving pain points in your market.
## Based On
Inspired by [Alex Finn's video on life-changing OpenClaw use cases](https://www.youtube.com/watch?v=41_TNGDDnfQ) and the [Last 30 Days skill](https://github.com/mvanhorn/last30days-skill/) by Matt Van Horde.
## Related Links
- [Last 30 Days Skill](https://github.com/mvanhorn/last30days-skill/)
- [OpenClaw Skills Directory](https://github.com/openclaw/skills)

82
openclaw/usecases/meeting-notes-action-items.md Normal file
View File

@@ -0,0 +1,82 @@
# Automated Meeting Notes & Action Items
You just finished a 45-minute team call. Now you need to write up the summary, pull out action items, and distribute them to Jira, Linear, or Todoist — manually. By the time you're done, the next meeting is starting. What if your agent handled all of that the moment the transcript lands?
This use case turns any meeting transcript into structured notes and automatically creates tasks in your project management tool.
## Pain Point
Meeting notes are tedious but critical. Most people either skip them (and lose context) or spend 20+ minutes writing them up. Action items get forgotten because they live in someone's head or buried in a chat thread. This agent eliminates the gap between "we discussed it" and "it's tracked and assigned."
## What It Does
- **Watches** for new meeting transcripts (via Otter.ai export, Google Meet transcript, Zoom recording summary, or a simple paste into chat)
- **Extracts** key decisions, discussion topics, and action items with owners and deadlines
- **Creates tasks** in Jira, Linear, Todoist, or Notion — assigned to the right person with context from the meeting
- **Posts a summary** to Slack or Discord so the whole team has a record
- **Follows up** — optionally pings assignees before deadlines via scheduled reminders
## Skills You Need
- Jira, Linear, Todoist, or Notion integration (for task creation)
- Slack or Discord integration (for posting summaries)
- File system access (for reading transcript files)
- Scheduling / cron (for follow-up reminders)
- Optional: Otter.ai, Fireflies.ai, or Google Meet API for automatic transcript retrieval
## How to Set It Up
1. Choose your transcript source. The simplest approach is pasting the transcript directly into chat. For automation, set up a folder watch or API integration.
2. Prompt OpenClaw:
```text
I just finished a meeting. Here's the transcript:
[paste transcript or point to file]
Please:
1. Write a concise summary (max 5 bullet points) covering key decisions and topics.
2. Extract ALL action items. For each one, identify:
- What needs to be done
- Who is responsible (match names to my team)
- Deadline (if mentioned, otherwise mark as "TBD")
3. Create a Jira ticket for each action item, assigned to the right person.
4. Post the full summary to #meeting-notes in Slack.
```
3. For fully automated pipeline (transcript folder watch):
```text
Set up a recurring task: every 30 minutes, check ~/meeting-transcripts/ for
new .txt or .vtt files. When you find one:
1. Parse the transcript into a structured summary with action items.
2. Create tasks in Linear for each action item.
3. Post the summary to #team-updates in Slack.
4. Move the processed file to ~/meeting-transcripts/processed/.
For each action item with a deadline, set a reminder to ping the assignee
in Slack one day before it's due.
```
4. Customize the output format:
```text
When writing meeting summaries, always use this structure:
- **Date & Attendees** at the top
- **Key Decisions** — numbered list of what was decided
- **Action Items** — table with columns: Task, Owner, Deadline, Status
- **Open Questions** — anything unresolved that needs follow-up
```
## Key Insights
- The real value isn't in the summary — it's in the **automatic task creation**. Meeting notes that don't become tracked tasks are just documentation theater.
- Pair this with the [Todoist Task Manager](todoist-task-manager.md) use case for full visibility into agent-created tasks.
- VTT/SRT subtitle files from Zoom or Google Meet work great as input — they include timestamps which help the agent attribute statements to speakers.
- Start simple (paste transcript, get summary) and automate incrementally. Don't over-engineer the pipeline before validating the output quality.
## Related Links
- [Otter.ai API](https://otter.ai/)
- [Jira REST API](https://developer.atlassian.com/cloud/jira/platform/rest/v3/)
- [Linear API](https://developers.linear.app/)
- [Slack API](https://api.slack.com/)

200
openclaw/usecases/multi-agent-team.md Normal file
View File

@@ -0,0 +1,200 @@
# Multi-Agent Specialized Team (Solo Founder Setup)
Solo founders wear every hat — strategy, development, marketing, sales, operations. Context-switching between these roles destroys deep work. Hiring is expensive and slow. What if you could spin up a small, specialized team of AI agents, each with a distinct role and personality, all controllable from a single chat interface?
This use case sets up multiple OpenClaw agents as a coordinated team, each specialized in a domain, communicating through shared memory and controlled via Telegram.
## Pain Point
- **One agent can't do everything well**: A single agent's context window fills up fast when juggling strategy, code, marketing research, and business analysis
- **No specialization**: Generic prompts produce generic outputs — a coding agent shouldn't also be crafting marketing copy
- **Solo founder burnout**: You need a team, not another tool to manage. The agents should work in the background and surface results, not require constant babysitting
- **Knowledge silos**: Insights from marketing research don't automatically inform dev priorities unless you manually bridge them
## What It Does
- **Specialized agents**: Each agent has a distinct role, personality, and model optimized for its domain
- **Shared memory**: Project docs, goals, and key decisions are accessible to all agents — nothing gets lost
- **Private context**: Each agent also maintains its own conversation history and domain-specific notes
- **Single control plane**: All agents are accessible through one Telegram group chat — tag the agent you need
- **Scheduled daily tasks**: Agents proactively work without being asked — content prompts, competitor monitoring, metric tracking
- **Parallel execution**: Multiple agents can work on independent tasks simultaneously
## Example Team Configuration
### Agent 1: Milo (Strategy Lead)
```text
## SOUL.md — Milo
You are Milo, the team lead. Confident, big-picture, charismatic.
Responsibilities:
- Strategic planning and prioritization
- Coordinating the other agents
- Weekly goal setting and OKR tracking
- Synthesizing insights from all agents into actionable decisions
Model: Claude Opus
Channel: Telegram (responds to @milo)
Daily tasks:
- 8:00 AM: Review overnight agent activity, post morning standup summary
- 6:00 PM: End-of-day recap with progress toward weekly goals
```
### Agent 2: Josh (Business & Growth)
```text
## SOUL.md — Josh
You are Josh, the business analyst. Pragmatic, straight to the point, numbers-driven.
Responsibilities:
- Pricing strategy and competitive analysis
- Growth metrics and KPI tracking
- Revenue modeling and unit economics
- Customer feedback analysis
Model: Claude Sonnet (fast, analytical)
Channel: Telegram (responds to @josh)
Daily tasks:
- 9:00 AM: Pull and summarize key metrics
- Track competitor pricing changes weekly
```
### Agent 3: Marketing Agent
```text
## SOUL.md — Marketing Agent
You are the marketing researcher. Creative, curious, trend-aware.
Responsibilities:
- Content ideation and drafting
- Competitor social media monitoring
- Reddit/HN/X trend tracking for relevant topics
- SEO keyword research
Model: Gemini (strong at web research and long-context analysis)
Channel: Telegram (responds to @marketing)
Daily tasks:
- 10:00 AM: Surface 3 content ideas based on trending topics
- Monitor competitor Reddit/X mentions daily
- Weekly content calendar draft
```
### Agent 4: Dev Agent
```text
## SOUL.md — Dev Agent
You are the dev agent. Precise, thorough, security-conscious.
Responsibilities:
- Coding and architecture decisions
- Code review and quality checks
- Bug investigation and fixing
- Technical documentation
Model: Claude Opus / Codex (for implementation)
Channel: Telegram (responds to @dev)
Daily tasks:
- Check CI/CD pipeline health
- Review open PRs
- Flag technical debt items
```
## Skills You Need
- `telegram` skill for the shared control interface
- `sessions_spawn` / `sessions_send` for multi-agent coordination
- Shared file system or note-taking tool for team memory
- Individual API keys for different model providers (if using mixed models)
- A VPS or always-on machine to run the agents
## How to Set It Up
### 1. Shared Memory Structure
```text
team/
├── GOALS.md # Current OKRs and priorities (all agents read)
├── DECISIONS.md # Key decisions log (append-only)
├── PROJECT_STATUS.md # Current project state (updated by all)
├── agents/
│ ├── milo/ # Milo's private context and notes
│ ├── josh/ # Josh's private context
│ ├── marketing/ # Marketing agent's research
│ └── dev/ # Dev agent's technical notes
```
### 2. Telegram Routing
Configure a single Telegram group where all agents listen, but each responds only when tagged:
```text
## AGENTS.md — Telegram Routing
Telegram group: "Team"
Routing:
- @milo → Strategy agent (spawns/resumes milo session)
- @josh → Business agent (spawns/resumes josh session)
- @marketing → Marketing agent (spawns/resumes marketing session)
- @dev → Dev agent (spawns/resumes dev session)
- @all → Broadcast to all agents
- No tag → Milo (team lead) handles by default
Each agent:
1. Reads shared GOALS.md and PROJECT_STATUS.md for context
2. Reads its own private notes
3. Processes the message
4. Responds in Telegram
5. Updates shared files if the response involves a decision or status change
```
### 3. Scheduled Tasks
```text
## HEARTBEAT.md — Team Schedule
Daily:
- 8:00 AM: Milo posts morning standup (aggregates overnight agent activity)
- 9:00 AM: Josh pulls key metrics
- 10:00 AM: Marketing surfaces content ideas from trending topics
- 6:00 PM: Milo posts end-of-day recap
Ongoing:
- Dev: Monitor CI/CD health, review PRs as they come in
- Marketing: Reddit/X keyword monitoring (every 2 hours)
- Josh: Competitor pricing checks (weekly)
Weekly:
- Monday: Milo drafts weekly priorities (input from all agents)
- Friday: Josh compiles weekly metrics report
```
## Key Insights
- **Personality matters more than you'd think**: Giving agents distinct names and communication styles makes it natural to "talk to your team" rather than wrestle with a generic AI
- **Shared memory + private context**: The combination is critical — agents need common ground (goals, decisions) but also their own space to accumulate domain expertise
- **Right model for the right job**: Don't use an expensive reasoning model for keyword monitoring. Match model capability to task complexity
- **Scheduled tasks are the flywheel**: The real value emerges when agents proactively surface insights, not just when you ask
- **Start with 2, not 4**: Begin with a lead + one specialist, then add agents as you identify bottlenecks
## Inspired By
This pattern was described by [Trebuh on X](https://x.com/iamtrebuh/status/2011260468975771862), a solo founder who set up 4 OpenClaw agents — Milo (strategy lead), Josh (business), a marketing agent, and a dev agent — all controlled through a single Telegram chat on a VPS. Each agent has its own personality, model, and scheduled tasks, while sharing project memory. He described it as "a real small team available 24/7."
The pattern was also confirmed on the [OpenClaw Showcase](https://openclaw.ai/showcase), where `@jdrhyne` reported running "15+ agents, 3 machines, 1 Discord server — IT built most of this, just by chatting," and `@nateliason` described a multi-model pipeline (prototype → summarize → optimize → implement → repeat) using different models at each stage. Another user, `@danpeguine`, runs two different OpenClaw instances collaborating in the same WhatsApp group.
## Related Links
- [OpenClaw Subagent Documentation](https://github.com/openclaw/openclaw)
- [OpenClaw Telegram Skill](https://github.com/openclaw/openclaw)
- [OpenClaw Showcase](https://openclaw.ai/showcase)
- [Anthropic: Building Effective Agents](https://www.anthropic.com/research/building-effective-agents)

62
openclaw/usecases/multi-channel-assistant.md Normal file
View File

@@ -0,0 +1,62 @@
# Multi-Channel Personal Assistant
Context-switching between apps to manage tasks, schedule events, send messages, and track work is exhausting. You want one interface that routes to all your tools.
This workflow consolidates everything into a single AI assistant:
• Telegram as primary interface with topic-based routing (different topics for video ideas, CRM, earnings, config, etc.)
• Slack integration for team collaboration (task assignment, knowledge base saves, video idea triggers)
• Google Workspace: create calendar events, manage email, upload to Drive — all from chat
• Todoist for quick task capture
• Asana for project management
• Automated reminders: trash day, weekly company letter, etc.
## Skills you Need
- `gog` CLI (Google Workspace)
- Slack integration (bot + user tokens)
- Todoist API or skill
- Asana API or skill
- Telegram channel with multiple topics configured
## How to Set it Up
1. Set up Telegram topics for different contexts:
- `config` — bot settings and debugging
- `updates` — status and notifications
- `video-ideas` — content pipeline
- `personal-crm` — contact management
- `earnings` — financial tracking
- `knowledge-base` — RAG ingestion and queries
2. Connect all your tools via OpenClaw config:
- Google OAuth (Gmail, Calendar, Drive)
- Slack (app + user tokens)
- Todoist API token
- Asana API token
3. Prompt OpenClaw:
```text
You are my multi-channel assistant. Route requests based on context:
Telegram topics:
- "config" → system settings, debugging
- "updates" → daily summaries, reminders, calendar
- "video-ideas" → content pipeline and research
- "personal-crm" → contact queries and meeting prep
- "earnings" → financial tracking
- "knowledge-base" → save and search content
When I ask you to:
- "Add [task] to my todo" → use Todoist
- "Create a card for [topic]" → use Asana Video Pipeline project
- "Schedule [event]" → use gog calendar
- "Email [person] about [topic]" → draft email via gog gmail
- "Upload [file] to Drive" → use gog drive
Set up automated reminders:
- Monday 6 PM: "🗑️ Trash day tomorrow"
- Friday 3 PM: "✍️ Time to write the weekly company update"
```
4. Test each integration individually, then test cross-workflow interactions (e.g., saving a Slack link to knowledge base, then using it in a video research card).

89
openclaw/usecases/multi-channel-customer-service.md Normal file
View File

@@ -0,0 +1,89 @@
# Multi-Channel AI Customer Service Platform
Small businesses juggle WhatsApp, Instagram DMs, emails, and Google Reviews across multiple apps. Customers expect instant responses 24/7, but hiring staff for round-the-clock coverage is expensive.
This use case consolidates all customer touchpoints into a single AI-powered inbox that responds intelligently on your behalf.
## What It Does
- **Unified inbox**: WhatsApp Business, Instagram DMs, Gmail, and Google Reviews in one place
- **AI auto-responses**: Handles FAQs, appointment requests, and common inquiries automatically
- **Human handoff**: Escalates complex issues or flags them for review
- **Test mode**: Demo the system to clients without affecting real customers
- **Business context**: Trained on your services, pricing, and policies
## Real Business Example
At Futurist Systems, we deploy this for local service businesses (restaurants, clinics, salons). One restaurant reduced response time from 4+ hours to under 2 minutes, handling 80% of inquiries automatically.
## Skills You Need
- WhatsApp Business API integration
- Instagram Graph API (via Meta Business)
- `gog` CLI for Gmail
- Google Business Profile API for reviews
- Message routing logic in AGENTS.md
## How to Set It Up
1. **Connect channels** via OpenClaw config:
- WhatsApp Business API (through 360dialog or official API)
- Instagram via Meta Business Suite
- Gmail via `gog` OAuth
- Google Business Profile API token
2. **Create business knowledge base**:
- Services and pricing
- Business hours and location
- FAQ responses
- Escalation triggers (e.g., complaints, refund requests)
3. **Configure AGENTS.md** with routing logic:
```text
## Customer Service Mode
When receiving customer messages:
1. Identify channel (WhatsApp/Instagram/Email/Review)
2. Check if test mode is enabled for this client
3. Classify intent:
- FAQ → respond from knowledge base
- Appointment → check availability, confirm booking
- Complaint → flag for human review, acknowledge receipt
- Review → thank for feedback, address concerns
Response style:
- Friendly, professional, concise
- Match the customer's language (ES/EN/UA)
- Never invent information not in knowledge base
- Sign off with business name
Test mode:
- Prefix responses with [TEST]
- Log but don't send to real channels
```
4. **Set up heartbeat checks** for response monitoring:
```text
## Heartbeat: Customer Service Check
Every 30 minutes:
- Check for unanswered messages > 5 min old
- Alert if response queue is backing up
- Log daily response metrics
```
## Key Insights
- **Language detection matters**: Auto-detect and respond in customer's language
- **Test mode is essential**: Clients need to see it work before going live
- **Handoff rules**: Define clear escalation triggers to avoid AI overreach
- **Response templates**: Pre-approved templates for sensitive topics (refunds, complaints)
## Related Links
- [WhatsApp Business API](https://developers.facebook.com/docs/whatsapp)
- [Instagram Messaging API](https://developers.facebook.com/docs/instagram-api/guides/messaging)
- [Google Business Profile API](https://developers.google.com/my-business)

56
openclaw/usecases/multi-source-tech-news-digest.md Normal file
View File

@@ -0,0 +1,56 @@
# Multi-Source Tech News Digest
Automatically aggregate, score, and deliver tech news from 109+ sources across RSS, Twitter/X, GitHub releases, and web search — all managed through natural language.
## Pain Point
Staying updated across AI, open-source, and frontier tech requires checking dozens of RSS feeds, Twitter accounts, GitHub repos, and news sites daily. Manual curation is time-consuming, and most existing tools either lack quality filtering or require complex configuration.
## What It Does
A four-layer data pipeline that runs on a schedule:
1. **RSS Feeds** (46 sources) — OpenAI, Hacker News, MIT Tech Review, etc.
2. **Twitter/X KOLs** (44 accounts) — @karpathy, @sama, @VitalikButerin, etc.
3. **GitHub Releases** (19 repos) — vLLM, LangChain, Ollama, Dify, etc.
4. **Web Search** (4 topic searches) — via Brave Search API
All articles are merged, deduplicated by title similarity, and quality-scored (priority source +3, multi-source +5, recency +2, engagement +1). The final digest is delivered to Discord, email, or Telegram.
The framework is fully customizable — add your own RSS feeds, Twitter handles, GitHub repos, or search queries in 30 seconds.
## Prompts
**Install and set up daily digest:**
```text
Install tech-news-digest from ClawHub. Set up a daily tech digest at 9am to Discord #tech-news channel. Also send it to my email at myemail@example.com.
```
**Add custom sources:**
```text
Add these to my tech digest sources:
- RSS: https://my-company-blog.com/feed
- Twitter: @myFavResearcher
- GitHub: my-org/my-framework
```
**Generate on demand:**
```text
Generate a tech digest for the past 24 hours and send it here.
```
## Skills Needed
- [tech-news-digest](https://clawhub.ai/skills/tech-news-digest) — Install via `clawhub install tech-news-digest`
- [gog](https://clawhub.ai/skills/gog) (optional) — For email delivery via Gmail
## Environment Variables (Optional)
- `X_BEARER_TOKEN` — Twitter/X API bearer token for KOL monitoring
- `BRAVE_API_KEY` — Brave Search API key for web search layer
- `GITHUB_TOKEN` — GitHub token for higher API rate limits
## Related Links
- [GitHub Repository](https://github.com/draco-agent/tech-news-digest)
- [ClawHub Page](https://clawhub.ai/skills/tech-news-digest)

107
openclaw/usecases/n8n-workflow-orchestration.md Normal file
View File

@@ -0,0 +1,107 @@
# OpenClaw + n8n Workflow Orchestration
Letting your AI agent directly manage API keys and call external services is a recipe for security incidents. Every new integration means another credential in `.env.local`, another surface for the agent to accidentally leak or misuse.
This use case describes a pattern where OpenClaw delegates all external API interactions to n8n workflows via webhooks — the agent never touches credentials, and every integration is visually inspectable and lockable.
## Pain Point
When OpenClaw handles everything directly, you get three compounding problems:
- **No visibility**: It's hard to inspect what the agent actually built when it's buried in JavaScript skill files or shell scripts
- **Credential sprawl**: Every API key lives in the agent's environment, one bad commit away from exposure
- **Wasted tokens**: Deterministic sub-tasks (send an email, update a spreadsheet) burn LLM reasoning tokens when they could run as simple workflows
## What It Does
- **Proxy pattern**: OpenClaw writes n8n workflows with incoming webhooks, then calls those webhooks for all future API interactions
- **Credential isolation**: API keys live in n8n's credential store — the agent only knows the webhook URL
- **Visual debugging**: Every workflow is inspectable in n8n's drag-and-drop UI
- **Lockable workflows**: Once a workflow is built and tested, you lock it so the agent can't modify how it interacts with the API
- **Safeguard steps**: You can add validation, rate limiting, and approval gates in n8n before any external call executes
## How It Works
1. **Agent designs the workflow**: Tell OpenClaw what you need (e.g., "create a workflow that sends a Slack message when a new GitHub issue is labeled `urgent`")
2. **Agent builds it in n8n**: OpenClaw creates the workflow via n8n's API, including an incoming webhook trigger
3. **You add credentials**: Open n8n's UI, add your Slack token / GitHub token manually
4. **You lock the workflow**: Prevent further modifications by the agent
5. **Agent calls the webhook**: From now on, OpenClaw calls `http://n8n:5678/webhook/my-workflow` with a JSON payload — it never sees the API key
```text
┌──────────────┐ webhook call ┌─────────────────┐ API call ┌──────────────┐
│ OpenClaw │ ───────────────────→ │ n8n Workflow │ ─────────────→ │ External │
│ (agent) │ (no credentials) │ (locked, with │ (credentials │ Service │
│ │ │ API keys) │ stay here) │ (Slack, etc)│
└──────────────┘ └─────────────────┘ └──────────────┘
```
## Skills You Need
- `n8n` API access (for creating/triggering workflows)
- `fetch` or `curl` for webhook calls
- Docker (if using the pre-configured stack)
- n8n credential management (manual, one-time setup per integration)
## How to Set It Up
### Option 1: Pre-configured Docker Stack
A community-maintained Docker Compose setup ([openclaw-n8n-stack](https://github.com/caprihan/openclaw-n8n-stack)) pre-wires everything on a shared Docker network:
```bash
git clone https://github.com/caprihan/openclaw-n8n-stack.git
cd openclaw-n8n-stack
cp .env.template .env
# Add your Anthropic API key to .env
docker-compose up -d
```
This gives you:
- OpenClaw on port 3456
- n8n on port 5678
- Shared Docker network so OpenClaw can call `http://n8n:5678/webhook/...` directly
- Pre-built workflow templates (multi-LLM fact-checking, email triage, social monitoring)
### Option 2: Manual Setup
1. Install n8n (`npm install n8n -g` or run via Docker)
2. Configure OpenClaw to know the n8n base URL
3. Add this to your AGENTS.md:
```text
## n8n Integration Pattern
When I need to interact with external APIs:
1. NEVER store API keys in my environment or skill files
2. Check if an n8n workflow already exists for this integration
3. If not, create one via n8n API with a webhook trigger
4. Notify the user to add credentials and lock the workflow
5. For all future calls, use the webhook URL with a JSON payload
Workflow naming: openclaw-{service}-{action}
Example: openclaw-slack-send-message
Webhook call format:
curl -X POST http://n8n:5678/webhook/{workflow-name} \
-H "Content-Type: application/json" \
-d '{"channel": "#general", "message": "Hello from OpenClaw"}'
```
## Key Insights
- **Three wins in one**: Observability (visual UI), security (credential isolation), and performance (deterministic workflows don't burn tokens)
- **Lock after testing**: The "build → test → lock" cycle is critical — without locking, the agent can silently modify workflows
- **n8n has 400+ integrations**: Most external services you'd want to connect already have n8n nodes, saving the agent from writing custom API calls
- **Audit trail for free**: n8n logs every workflow execution with input/output data
## Inspired By
This pattern was described by [Simon Høiberg](https://x.com/SimonHoiberg/status/2020843874382487959), who outlined three reasons this approach beats letting OpenClaw handle API interactions directly: observability through n8n's visual UI, security through credential isolation, and performance by running deterministic sub-tasks as workflows instead of LLM calls. The [openclaw-n8n-stack](https://github.com/caprihan/openclaw-n8n-stack) repository provides a ready-to-run Docker Compose setup implementing this pattern.
## Related Links
- [n8n Documentation](https://docs.n8n.io/)
- [openclaw-n8n-stack (Docker setup)](https://github.com/caprihan/openclaw-n8n-stack)
- [n8n Webhook Trigger Docs](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.webhook/)

125
openclaw/usecases/overnight-mini-app-builder.md Normal file
View File

@@ -0,0 +1,125 @@
# Goal-Driven Autonomous Tasks
Your AI agent is powerful but reactive — it only works when you tell it what to do. What if it knew your goals and proactively came up with tasks to move you closer to them every single day, without being asked?
This workflow turns OpenClaw into a self-directed employee. You brain dump your goals once, and the agent autonomously generates, schedules, and completes tasks that advance those goals — including building you surprise mini-apps overnight.
## What It Does
- You brain dump all your goals, missions, and objectives into OpenClaw (personal and professional)
- Every morning, the agent generates 4-5 tasks it can complete autonomously on your computer
- Tasks go beyond app building: research, writing scripts, building features, creating content, analyzing competitors
- The agent executes the tasks itself and tracks them on a custom Kanban board it builds for you
- You can also have it build you a surprise mini-app every night — a new SaaS idea, a tool that automates a boring part of your life, shipped as an MVP
## Pain Point
Most people have big goals but struggle to break them into daily actionable steps. And even when they do, execution takes all their time. This system offloads both the planning AND the execution to your AI agent. You define the destination; the agent figures out the daily steps and walks them.
## Skills You Need
- Telegram or Discord integration
- `sessions_spawn` / `sessions_send` for autonomous task execution
- Next.js or similar (for the Kanban board — OpenClaw builds it for you)
## How to Set It Up
### Step 1: Brain Dump Your Goals
This is the most important step. Text your OpenClaw everything you're trying to accomplish:
```text
Here are my goals and missions. Remember all of this:
Career:
- Grow my YouTube channel to 100k subscribers
- Launch my SaaS product by Q3
- Build a community around AI education
Personal:
- Read 2 books per month
- Learn Spanish
Business:
- Scale revenue to $10k/month
- Build partnerships with 5 companies in my space
- Automate as much of my workflow as possible
Use this context for everything you do going forward.
```
### Step 2: Set Up Autonomous Daily Tasks
```text
Every morning at 8:00 AM, come up with 4-5 tasks that you can complete
on my computer today that bring me closer to my goals.
Then schedule and complete those tasks yourself. Examples:
- Research competitors and write analysis reports
- Draft video scripts based on trending topics
- Build new features for my apps
- Write and schedule social media content
- Research potential business partnerships
- Build me a surprise mini-app MVP that gets me closer to one of my goals
Track all tasks on a Kanban board. Update the board as you complete them.
```
### Step 3: Build the Kanban Board (Optional)
```text
Build me a Kanban board in Next.js where I can see all the tasks you're
working on. Show columns for To Do, In Progress, and Done. Update it
in real-time as you complete tasks.
```
## Key Insights
- The **brain dump is everything**. The more context you give about your goals, the better the agent's daily tasks will be. Don't hold back.
- The agent discovers tasks you wouldn't have thought of. It connects dots across your goals and finds opportunities you'd miss.
- The Kanban board turns your agent into a trackable employee. You can see exactly what it's been doing and course-correct.
- For overnight app building specifically: explicitly tell it to build MVPs and not to overcomplicate. You'll wake up every morning with a new surprise.
- This compounds over time — the agent learns what kinds of tasks are most helpful and adjusts.
## Pitfalls & Patterns (Learned in Production)
### ⚠️ Race Condition: Sub-Agents Editing Shared Files
When you run this workflow with sub-agents, both the main session and spawned sub-agents may try to update the same task file (e.g., your Kanban/AUTONOMOUS.md). This causes silent failures.
**Why it happens:** OpenClaw's `edit` tool requires an exact `oldText` match. If a sub-agent updates a line between the time your main session reads the file and tries to edit it, the text no longer matches — the edit silently fails.
**The fix: split your task file into two roles:**
1. **`AUTONOMOUS.md`** — stays small and clean. Contains only goals + open backlog. Only the main session touches this. Sub-agents never edit it.
2. **`memory/tasks-log.md`** — append-only log. Sub-agents only ever *add new lines at the bottom*. Never edit existing lines.
```markdown
# tasks-log.md — Completed Tasks (append-only)
# Sub-agents: always append to the END. Never edit existing lines.
### 2026-02-24
- ✅ TASK-001: Research competitors → research/competitors.md
- ✅ TASK-002: Draft blog post → drafts/post-1.md
```
This pattern is borrowed from Git's commit log: you never rewrite history, you only add new commits. It eliminates race conditions entirely and has a bonus: `AUTONOMOUS.md` stays small, so it costs fewer tokens every time it's loaded in a heartbeat.
**Rule to give your agent:** In sub-agent spawn instructions, always include:
> "When done, append a ✅ line to `memory/tasks-log.md`. Never edit `AUTONOMOUS.md` directly."
### 💡 Keep AUTONOMOUS.md Token-Light
The task tracking file gets loaded on every heartbeat poll. If it grows unbounded with completed tasks, you'll burn tokens unnecessarily.
Keep `AUTONOMOUS.md` under ~50 lines: goals (one-liners) + open backlog only. Archive everything completed to a separate file that is only read on-demand.
## Based On
Inspired by [Alex Finn](https://www.youtube.com/watch?v=UTCi_q6iuCM&t=414s) and his [video on life-changing OpenClaw use cases](https://www.youtube.com/watch?v=41_TNGDDnfQ).
## Related Links
- [OpenClaw Memory System](https://github.com/openclaw/openclaw)
- [OpenClaw Subagent Docs](https://github.com/openclaw/openclaw)

46
openclaw/usecases/personal-crm.md Normal file
View File

@@ -0,0 +1,46 @@
# Personal CRM with Automatic Contact Discovery
Keeping track of who you've met, when, and what you discussed is impossible to do manually. Important follow-ups slip through the cracks, and you forget context before important meetings.
This workflow builds and maintains a personal CRM automatically:
• Daily cron job scans email and calendar for new contacts and interactions
• Stores contacts in a structured database with relationship context
• Natural language queries: "What do I know about [person]?", "Who needs follow-up?", "When did I last talk to [person]?"
• Daily meeting prep briefing: before each day's meetings, researches external attendees via CRM + email history and delivers a briefing
## Skills you Need
- `gog` CLI (for Gmail and Google Calendar)
- Custom CRM database (SQLite or similar) or use the [crm-query](https://clawhub.ai) skill if available
- Telegram topic for CRM queries
## How to Set it Up
1. Create a CRM database:
```sql
CREATE TABLE contacts (
id INTEGER PRIMARY KEY,
name TEXT,
email TEXT,
first_seen TEXT,
last_contact TEXT,
interaction_count INTEGER,
notes TEXT
);
```
2. Set up a Telegram topic called "personal-crm" for queries.
3. Prompt OpenClaw:
```text
Run a daily cron job at 6 AM to:
1. Scan my Gmail and Calendar for the past 24 hours
2. Extract new contacts and update existing ones
3. Log interactions (meetings, emails) with timestamps and context
Also, every morning at 7 AM:
1. Check my calendar for today's meetings
2. For each external attendee, search my CRM and email history
3. Deliver a briefing to Telegram with: who they are, when we last spoke, what we discussed, and any follow-up items
When I ask about a contact in the personal-crm topic, search the database and give me everything you know.
```

38
openclaw/usecases/phone-based-personal-assistant.md Normal file
View File

@@ -0,0 +1,38 @@
# Phone-Based Personal Assistant
## Pain Point
You want to access your AI agent from any phone without needing a smartphone app or internet browser. You need hands-free voice assistance while driving, walking, or when your hands are occupied.
## What It Does
ClawdTalk enables OpenClaw to receive and make phone calls, turning any phone into a gateway to your AI assistant. You can:
- Call a phone number to speak with your AI agent via voice
- Get calendar reminders, Jira updates, and web search results via voice
- Integrate with Telnyx for reliable phone connectivity
SMS support is coming soon.
## Prompts
```
You are available via phone. When I call, greet me and ask how I can help.
For calendar queries: "What's on my calendar today?"
For Jira updates: "Show me my open tickets"
For web search: "Search for latest news on AI agents"
```
## Skills Needed
- [ClawdTalk](https://github.com/team-telnyx/clawdtalk-client)
- Calendar skill (Google Calendar or Outlook)
- Jira skill
- Web search skill
## Related Links
- [ClawdTalk Website](https://clawdtalk.com)
- [ClawdTalk GitHub](https://github.com/team-telnyx/clawdtalk-client)
- [Telnyx API](https://telnyx.com/)
- [OpenClaw Skills](https://github.com/openclaw/skills)

73
openclaw/usecases/phone-call-notifications.md Normal file
View File

@@ -0,0 +1,73 @@
# Phone Call Notifications
Your agent already monitors things for you — stocks, emails, smart home, calendars — but notifications are easy to ignore. Push notifications pile up. Chat messages get buried. For the stuff that actually matters, you need something you can't swipe away.
This use case gives your agent a phone call as a notification channel. When something is urgent enough, the agent dials your real phone number, tells you what's going on, and you can talk back. Two-way conversation, not a robocall.
## What It Does
- Agent decides something is worth your attention (price alert, urgent email, appointment reminder, anything)
- Agent calls your phone via [clawr.ing](https://clawr.ing), a managed calling service — no Twilio setup, no API keys to configure
- You pick up, hear the alert, and can ask follow-up questions in real time
- Call ends when the conversation is done
The key idea: the agent calls YOU. You don't call the agent. This works with heartbeat checks, cron jobs, or any trigger — the agent evaluates whether something is phone-call-worthy and acts on it.
## Why This Works
OpenClaw agents already have initiative — heartbeat, cron, event triggers. But their output channels are limited to chat platforms you might not be checking. A phone call is the one notification channel that reliably gets your attention, especially when you're away from your desk.
clawr.ing handles the telephony infrastructure. You paste one setup prompt and the agent gains the ability to call. No Twilio account, no phone number provisioning, no webhook configuration. The service covers 100+ countries with real PSTN calls (not VoIP overlays).
## Skills Needed
- [clawr.ing](https://clawhub.ai/marcospgp/clawring) — install by pasting the setup prompt from the [clawr.ing dashboard](https://clawr.ing) into your OpenClaw chat. No CLI install needed.
That's it. No other dependencies. The setup prompt includes the API key and links to skill docs — the agent reads them and figures out the rest.
## Example: Morning Briefing Call
Set up a cron job that calls you every morning with a personalized briefing:
```
Every weekday at 7:30 AM, call me with a morning briefing. Include:
- Weather forecast for my city
- My calendar for today
- Any urgent emails that came in overnight
- Top 3 news headlines relevant to my interests
Keep it concise — aim for under 2 minutes. If I ask questions, answer them.
If I don't pick up, don't retry.
```
## Example: Price Alert
Tell the agent what to watch and when to call:
```
Monitor NVDA stock price. If it drops more than 5% in a single day,
call me immediately and tell me what happened. Include any relevant
news that might explain the drop.
```
## Example: Urgent Email Filter
```
During business hours, check my inbox every 15 minutes.
If you see an email from my boss or any email marked urgent,
call me with a summary. For everything else, just send a chat message.
```
## Key Insights
- **Don't overuse it.** The whole point is that a phone call means "this actually matters." If your agent calls you 10 times a day, you'll start ignoring it. Set clear thresholds for what's call-worthy vs chat-worthy.
- **Pair with heartbeat or cron.** clawr.ing is the delivery channel — you still need a trigger. Heartbeat checks (every 30 min) work for monitoring tasks. Cron jobs work for scheduled briefings.
- **Two-way conversation.** Unlike a push notification, you can ask follow-up questions on the call. "Wait, which email?" or "What's the current price now?" — the agent responds in real time.
- **Fast model for calls.** Phone conversations need quick responses. If your OpenClaw supports skill-level model routing, assign clawr.ing to a fast model (Haiku-class). The thinking sound covers latency, but faster is always better.
- **Privacy.** clawr.ing doesn't store recordings or transcripts. Audio is encrypted in transit and discarded after processing.
## Related Links
- [clawr.ing](https://clawr.ing)
- [clawr.ing on ClawHub](https://clawhub.ai/marcospgp/clawring)
- [OpenClaw](https://github.com/openclaw/openclaw)

93
openclaw/usecases/podcast-production-pipeline.md Normal file
View File

@@ -0,0 +1,93 @@
# Podcast Production Pipeline
You have a podcast idea, maybe even a backlog of episode topics. But between researching guests, writing outlines, drafting intros, generating show notes, and writing social media posts for promotion — the production overhead kills your momentum. What if you handed off a topic and got back a full production package?
This use case chains agents together to handle the entire podcast production workflow from topic to publish-ready assets.
## Pain Point
Solo podcasters and small teams spend more time on production than on actually recording. Research takes hours, show notes are an afterthought, and social media promotion is the first thing that gets skipped. The creative part — the conversation — is maybe 30% of the total effort. This agent handles the other 70%.
## What It Does
- **Episode Research** — given a topic or guest name, compiles background research, talking points, and suggested questions
- **Outline & Script** — generates a structured episode outline with intro script, segment transitions, and closing remarks
- **Show Notes** — after recording, processes the transcript into timestamped show notes with links to everything mentioned
- **Social Media Kit** — creates promotional posts for X, LinkedIn, and Instagram with episode highlights and pull quotes
- **Episode Description** — writes SEO-optimized episode descriptions for Spotify, Apple Podcasts, and YouTube
## Skills You Need
- Web search / research skill (for guest research and topic deep-dives)
- File system access (for reading transcripts and writing output files)
- Slack, Discord, or Telegram integration (for delivering assets)
- Optional: `sessions_spawn` for running research and writing agents in parallel
- Optional: RSS feed skill (for monitoring competitor podcasts)
## How to Set It Up
1. Pre-recording — generate research and outline:
```text
I'm recording a podcast episode about [TOPIC]. My guest is [NAME].
Please:
1. Research the guest — their background, recent work, hot takes, and
anything controversial or interesting they've said publicly.
2. Research the topic — key trends, recent news, common misconceptions,
and what the audience likely already knows vs. what would surprise them.
3. Generate an episode outline:
- Cold open hook (1-2 sentences to grab attention)
- Intro script (30 seconds, casual tone)
- 5-7 interview questions, ordered from easy/rapport-building to deep/provocative
- 2-3 "back pocket" questions in case the conversation stalls
- Closing segment with call-to-action
Save everything to ~/podcast/episodes/[episode-number]/prep/
```
2. Post-recording — generate show notes and promo:
```text
Here's the transcript for Episode [NUMBER]: [paste or point to file]
Please:
1. Write timestamped show notes — every major topic shift gets a timestamp
and one-line summary. Include links to anything mentioned (tools, books,
articles, people).
2. Write an episode description (max 200 words) optimized for podcast
search. Include 3-5 relevant keywords naturally.
3. Create social media posts:
- X/Twitter: 3 tweets — one pull quote, one key insight, one question
to spark discussion. Each under 280 chars.
- LinkedIn: 1 post, professional tone, 100-150 words.
- Instagram caption: 1 post with emoji, casual tone, include relevant hashtags.
4. Extract a "highlights" list — the 3 most interesting/surprising moments
with timestamps.
Save everything to ~/podcast/episodes/[episode-number]/publish/
```
3. Optional — competitor monitoring:
```text
Monitor these podcast RSS feeds daily:
- [feed URL 1]
- [feed URL 2]
When a new episode drops that covers a topic relevant to my podcast,
send me a Telegram message with:
- Episode title and link
- One-sentence summary
- Whether this is something I should respond to or cover from my angle
```
## Key Insights
- The **pre-recording research** is where most value is. Walking into an interview with deep guest research makes the conversation dramatically better — and that's something you can't fake in post-production.
- Show notes with timestamps are a huge listener retention tool. Most podcasters skip them because they're tedious. This agent makes them effortless.
- The social media kit saves the most *recurring* time. You need promo for every single episode, and it's always the same structure — perfect for automation.
- Pairs well with the [Multi-Agent Content Factory](content-factory.md) if you want to repurpose podcast content into blog posts, newsletters, or video clips.
## Related Links
- [Podcast RSS Feed Spec](https://podcasters.apple.com/support/823-podcast-requirements)
- [Spotify for Podcasters](https://podcasters.spotify.com/)
- [Whisper (OpenAI)](https://github.com/openai/whisper) — for local transcript generation

90
openclaw/usecases/polymarket-autopilot.md Normal file
View File

@@ -0,0 +1,90 @@
# Polymarket Autopilot: Automated Paper Trading
Manually monitoring prediction markets for arbitrage opportunities and executing trades is time-consuming and requires constant attention. You want to test and refine trading strategies without risking real capital.
This workflow automates paper trading on Polymarket with custom strategies:
• Monitors market data via API (prices, volume, spreads)
• Executes paper trades using TAIL (trend-following) and BONDING (contrarian) strategies
• Tracks portfolio performance, P&L, and win rate
• Delivers daily summaries to Discord with trade logs and insights
• Learns from patterns: adjusts strategy parameters based on backtesting results
## Pain Point
Prediction markets move fast. Manual trading means missing opportunities, emotional decisions, and difficulty tracking what works. Testing strategies with real money risks losses before you understand market behavior.
## What It Does
The autopilot continuously scans Polymarket for opportunities, simulates trades using configurable strategies, and logs everything for analysis. You wake up to a summary of what it "traded" overnight, what worked, and what didn't.
Example strategies:
- **TAIL**: Follow trends when volume spikes and momentum is clear
- **BONDING**: Buy contrarian positions when markets overreact to news
- **SPREAD**: Identify mispriced markets with arbitrage potential
## Skills Needed
- `web_search` or `web_fetch` (for Polymarket API data)
- `postgres` or SQLite for trade logs and portfolio tracking
- Discord integration for daily reports
- Cron jobs for continuous monitoring
- Sub-agent spawning for parallel market analysis
## How to Set it Up
1. Set up a database for paper trading:
```sql
CREATE TABLE paper_trades (
id SERIAL PRIMARY KEY,
market_id TEXT,
market_name TEXT,
strategy TEXT,
direction TEXT,
entry_price DECIMAL,
exit_price DECIMAL,
quantity DECIMAL,
pnl DECIMAL,
timestamp TIMESTAMPTZ DEFAULT NOW()
);
CREATE TABLE portfolio (
id SERIAL PRIMARY KEY,
total_value DECIMAL,
cash DECIMAL,
positions JSONB,
updated_at TIMESTAMPTZ DEFAULT NOW()
);
```
2. Create a Discord channel for updates (e.g., #polymarket-autopilot).
3. Prompt OpenClaw:
```text
You are a Polymarket paper trading autopilot. Run continuously (via cron every 15 minutes):
1. Fetch current market data from Polymarket API
2. Analyze opportunities using these strategies:
- TAIL: Follow strong trends (>60% probability + volume spike)
- BONDING: Contrarian plays on overreactions (sudden drops >10% on news)
- SPREAD: Arbitrage when YES+NO > 1.05
3. Execute paper trades in the database (starting capital: $10,000)
4. Track portfolio state and update positions
Every morning at 8 AM, post a summary to Discord #polymarket-autopilot:
- Yesterday's trades (entry/exit prices, P&L)
- Current portfolio value and open positions
- Win rate and strategy performance
- Market insights and recommendations
Use sub-agents to analyze multiple markets in parallel during high-volume periods.
Never use real money. This is paper trading only.
```
4. Iterate on strategies based on performance. Adjust thresholds, add new strategies, backtest historical data.
## Related Links
- [Polymarket API](https://docs.polymarket.com/)
- [Paper Trading Best Practices](https://www.investopedia.com/articles/trading/11/paper-trading.asp)

104
openclaw/usecases/pre-build-idea-validator.md Normal file
View File

@@ -0,0 +1,104 @@
# Pre-Build Idea Validator
Before OpenClaw starts building anything new, it automatically checks whether the idea already exists across GitHub, Hacker News, npm, PyPI, and Product Hunt — and adjusts its approach based on what it finds.
## What It Does
- Scans 5 real data sources (GitHub, Hacker News, npm, PyPI, Product Hunt) before any code is written
- Returns a `reality_signal` score (0-100) indicating how crowded the space is
- Shows top competitors with star counts and descriptions
- Suggests pivot directions when the space is saturated
- Works as a pre-build gate: high signal = stop and discuss, low signal = proceed
## Pain Point
You tell your agent "build me an AI code review tool" and it happily spends 6 hours coding. Meanwhile, 143,000+ repos already exist on GitHub — the top one has 53,000 stars. The agent never checks because you never asked, and it doesn't know to look. You only discover competitors after you've invested significant time. This pattern repeats for every new project idea.
## Skills You Need
- [idea-reality-mcp](https://github.com/mnemox-ai/idea-reality-mcp) — MCP server that scans real data sources and returns a competition score
## How to Set It Up
1. Install idea-reality-mcp:
```bash
uvx idea-reality-mcp
```
2. Add the MCP server to your OpenClaw config:
```json
{
"mcpServers": {
"idea-reality": {
"command": "uvx",
"args": ["idea-reality-mcp"]
}
}
}
```
3. Add this to your OpenClaw agent instructions:
```text
Before starting any new project, feature, or tool, always run idea_check first.
Rules:
- If reality_signal > 70: STOP. Report the top 3 competitors with star counts.
Ask me if I want to proceed, pivot, or abandon.
- If reality_signal 30-70: Show me the results and pivot_hints.
Suggest a niche angle that existing projects don't cover.
- If reality_signal < 30: Proceed to build.
Mention that the space is open.
- Always show the reality_signal score and top competitors before writing any code.
```
## Real World Example
**You:** "Build me a CLI tool for AI code review"
OpenClaw runs `idea_check("AI code review tool")` and responds:
> **reality_signal: 90/100 (very high)**
>
> Top competitors:
> 1. Gitea — 53,940 stars
> 2. reviewdog — 9,104 stars
> 3. Danger (Ruby) — 5,649 stars
>
> This space has 143,000+ related repos. The top players are mature and well-funded.
>
> **Pivot suggestions:**
> - Focus on a specific language (Rust/Go-only AI code review)
> - Target a specific framework (React/Vue component review)
> - Target a specific industry (financial/medical code compliance review)
>
> Should I proceed with a differentiated angle, or pivot to something else?
**You:** "What about an MCP server for pre-build idea validation?"
> **reality_signal: 8/100 (very low)**
>
> 0 direct competitors found on PyPI or npm. GitHub has some tangentially related repos but none solve this exact problem.
>
> The space is wide open. Proceeding to build.
## Variations
- **Deep mode for serious decisions**: Use `depth="deep"` to scan all 5 sources in parallel (GitHub + HN + npm + PyPI + Product Hunt) for major project decisions.
- **Batch validation**: Before a hackathon, give OpenClaw a list of 10 ideas and have it rank them by `reality_signal` — lowest score = most original opportunity.
- **Web demo first**: Try without installing at [mnemox.ai/check](https://mnemox.ai/check) to see if the workflow fits your needs.
## Key Insights
- This prevents the most expensive mistake in building: **solving a problem that's already been solved**.
- The `reality_signal` is based on real data (repo counts, star distributions, HN discussion volume), not LLM guessing.
- A high score doesn't mean "don't build" — it means "differentiate or don't bother."
- A low score means genuine white space exists. That's where solo builders have the best odds.
## Related Links
- [idea-reality-mcp GitHub](https://github.com/mnemox-ai/idea-reality-mcp)
- [Web demo](https://mnemox.ai/check) (try without installing)
- [PyPI](https://pypi.org/project/idea-reality-mcp/)

97
openclaw/usecases/project-state-management.md Normal file
View File

@@ -0,0 +1,97 @@
# Project State Management System: Event-Driven Alternative to Kanban
Traditional Kanban boards are static and require manual updates. You forget to move cards, lose context between sessions, and can't track the "why" behind state changes. Projects drift without clear visibility.
This workflow replaces Kanban with an event-driven system that tracks project state automatically:
• Stores project state in a database with full history
• Captures context: decisions, blockers, next steps, key insights
• Event-driven updates: "Just finished X, blocked on Y" → automatic state transition
• Natural language queries: "What's the status of [project]?", "Why did we pivot on [feature]?"
• Daily standup summaries: What happened yesterday, what's planned today, what's blocked
• Git integration: links commits to project events for traceability
## Pain Point
Kanban boards become stale. You waste time updating cards instead of doing work. Context gets lost—three months later, you can't remember why you made a key decision. There's no automatic link between code changes and project progress.
## What It Does
Instead of dragging cards, you chat with your assistant: "Finished the auth flow, starting on the dashboard." The system logs the event, updates project state, and preserves context. When you ask "Where are we on the dashboard?" it gives you the full story: what's done, what's next, what's blocking you, and why.
Git commits are automatically scanned and linked to projects. Your daily standup summary writes itself.
## Skills Needed
- `postgres` or SQLite for project state database
- `github` (gh CLI) for commit tracking
- Discord or Telegram for updates and queries
- Cron jobs for daily summaries
- Sub-agents for parallel project analysis
## How to Set it Up
1. Set up a project state database:
```sql
CREATE TABLE projects (
id SERIAL PRIMARY KEY,
name TEXT UNIQUE,
status TEXT, -- e.g., "active", "blocked", "completed"
current_phase TEXT,
last_update TIMESTAMPTZ DEFAULT NOW()
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
project_id INTEGER REFERENCES projects(id),
event_type TEXT, -- e.g., "progress", "blocker", "decision", "pivot"
description TEXT,
context TEXT,
timestamp TIMESTAMPTZ DEFAULT NOW()
);
CREATE TABLE blockers (
id SERIAL PRIMARY KEY,
project_id INTEGER REFERENCES projects(id),
blocker_text TEXT,
status TEXT DEFAULT 'open', -- "open", "resolved"
created_at TIMESTAMPTZ DEFAULT NOW(),
resolved_at TIMESTAMPTZ
);
```
2. Create a Discord channel for project updates (e.g., #project-state).
3. Prompt OpenClaw:
```text
You are my project state manager. Instead of Kanban, I'll tell you what I'm working on conversationally.
When I say things like:
- "Finished [task]" → log a "progress" event, update project state
- "Blocked on [issue]" → create a blocker entry, update project status to "blocked"
- "Starting [new task]" → log a "progress" event, update current phase
- "Decided to [decision]" → log a "decision" event with full context
- "Pivoting to [new approach]" → log a "pivot" event with reasoning
When I ask:
- "What's the status of [project]?" → fetch latest events, blockers, and current phase
- "Why did we decide [X]?" → search events for decision context
- "What's blocking us?" → list all open blockers across projects
Every morning at 9 AM, run a cron job to:
1. Scan git commits from the past 24 hours (via gh CLI)
2. Link commits to projects based on branch names or commit messages
3. Post a daily standup summary to Discord #project-state:
- What happened yesterday (events + commits)
- What's planned today (based on current phase and recent conversations)
- What's blocked (open blockers)
When I'm planning a sprint, spawn a sub-agent to analyze each project's state and suggest priorities.
```
4. Integrate with your workflow: Just talk to your assistant naturally about what you're doing. The system captures everything.
## Related Links
- [Event Sourcing Pattern](https://martinfowler.com/eaaDev/EventSourcing.html)
- [Why Kanban Fails for Solo Developers](https://blog.nuclino.com/why-kanban-doesnt-work-for-me)

64
openclaw/usecases/second-brain.md Normal file
View File

@@ -0,0 +1,64 @@
# Second Brain
You come up with ideas, find interesting links, hear about books to read — but you never have a good system for capturing them. Notion gets complex, Apple Notes becomes a graveyard of 10,000 unread entries. You need something as simple as texting a friend.
This workflow turns OpenClaw into a memory-capture system you interact with via text message, backed by a custom searchable UI you can browse anytime.
## What It Does
- Text anything to your OpenClaw via Telegram, iMessage, or Discord — "Remind me to read a book about local LLMs" — and it remembers it instantly
- OpenClaw's built-in memory system stores everything you tell it permanently
- A custom Next.js dashboard lets you search through every memory, conversation, and note
- Global search (Cmd+K) across all memories, documents, and tasks
- No folders, no tags, no complex organization — just text and search
## Pain Point
Every note-taking app eventually becomes a chore. You stop using it because the friction of organizing is higher than the friction of forgetting. The key insight is: **capture should be as easy as texting, and retrieval should be as easy as searching**.
## Skills You Need
- Telegram, iMessage, or Discord integration (for text-based capture)
- Next.js (OpenClaw builds this for you — no coding needed)
## How to Set It Up
1. Make sure your OpenClaw is connected to your preferred messaging platform (Telegram, Discord, etc.).
2. Start using it immediately — just text your bot anything you want to remember:
```text
Hey, remind me to read "Designing Data-Intensive Applications"
Save this link: https://example.com/interesting-article
Remember: John recommended the restaurant on 5th street
```
3. Build the searchable UI by prompting OpenClaw:
```text
I want to build a second brain system where I can review all our notes,
conversations, and memories. Please build that out with Next.js.
Include:
- A searchable list of all memories and conversations
- Global search (Cmd+K) across everything
- Ability to filter by date and type
- Clean, minimal UI
```
4. OpenClaw will build and deploy the entire Next.js app for you. Navigate to the URL it provides and you have your second brain dashboard.
5. From now on, whenever you think of something — on the road, in a meeting, before bed — just text your bot. Come back to the dashboard whenever you need to find something.
## Key Insights
- The power is in the **zero-friction capture**. You don't need to open an app, pick a folder, or add tags. Just text.
- OpenClaw's memory system is cumulative — it remembers *everything* you've ever told it, making it more powerful over time.
- You can text your bot from your phone and it builds things on your computer. The interface is the conversation.
## Based On
Inspired by [Alex Finn's video on life-changing OpenClaw use cases](https://www.youtube.com/watch?v=41_TNGDDnfQ).
## Related Links
- [OpenClaw Memory System](https://github.com/openclaw/openclaw)
- [Building a Second Brain (Tiago Forte)](https://www.buildingasecondbrain.com/)

182
openclaw/usecases/self-healing-home-server.md Normal file
View File

@@ -0,0 +1,182 @@
# Self-Healing Home Server & Infrastructure Management
Running a home server means being on-call 24/7 for your own infrastructure. Services go down at 3 AM, certificates expire silently, disk fills up, and pods crash-loop — all while you're asleep or away.
This use case turns OpenClaw into a persistent infrastructure agent with SSH access, automated cron jobs, and the ability to detect, diagnose, and fix issues before you know there's a problem.
## Pain Point
Home lab operators and self-hosters face a constant maintenance burden:
- Health checks, log monitoring, and alerting require manual setup and attention
- When something breaks, you have to SSH in, diagnose, and fix — often from your phone
- Infrastructure-as-code (Terraform, Ansible, Kubernetes manifests) needs regular updates
- Knowledge about your setup lives in your head, not in searchable documentation
- Routine tasks (email triage, deployment checks, security audits) eat hours every week
## What It Does
- **Automated health monitoring**: Cron-based checks on services, deployments, and system resources
- **Self-healing**: Detects issues via health checks and applies fixes autonomously (restart pods, scale resources, fix configs)
- **Infrastructure management**: Writes and applies Terraform, Ansible, and Kubernetes manifests
- **Morning briefings**: Daily summary of system health, calendar, weather, and task board status
- **Email triage**: Scans inbox, labels actionable items, archives noise
- **Knowledge extraction**: Processes notes and conversation exports into a structured, searchable knowledge base
- **Blog publishing pipeline**: Draft → generate banner → publish to CMS → deploy to hosting — fully automated
- **Security auditing**: Regular scans for hardcoded secrets, privileged containers, and overly permissive access
## Skills You Need
- `ssh` access to home network machines
- `kubectl` for Kubernetes cluster management
- `terraform` and `ansible` for infrastructure-as-code
- `1password` CLI for secrets management
- `gog` CLI for email access
- Calendar API access
- Obsidian vault or notes directory (for knowledge base)
- `openclaw doctor` for self-diagnostics
## How to Set It Up
### 1. Core Agent Configuration
Name your agent and define its access scope in AGENTS.md:
```text
## Infrastructure Agent
You are Reef, an infrastructure management agent.
Access:
- SSH to all machines on the home network (192.168.1.0/24)
- kubectl for the K3s cluster
- 1Password vault (read-only for credentials, dedicated AI vault)
- Gmail via gog CLI
- Calendar (yours + partner's)
- Obsidian vault at ~/Documents/Obsidian/
Rules:
- NEVER hardcode secrets — always use 1Password CLI or environment variables
- NEVER push directly to main — always create a PR
- Run `openclaw doctor` as part of self-health checks
- Log all infrastructure changes to ~/logs/infra-changes.md
```
### 2. Automated Cron Job System
The power of this setup is the scheduled job system. Configure in HEARTBEAT.md:
```text
## Cron Schedule
Every 15 minutes:
- Check kanban board for in-progress tasks → continue work
Every hour:
- Monitor health checks (Gatus, ArgoCD, service endpoints)
- Triage Gmail (label actionable items, archive noise)
- Check for unanswered alerts or notifications
Every 6 hours:
- Knowledge base data entry (process new Obsidian notes)
- Self health check (openclaw doctor, disk usage, memory, logs)
Every 12 hours:
- Code quality and documentation audit
- Log analysis via Loki/monitoring stack
Daily:
- 4:00 AM: Nightly brainstorm (explore connections between notes)
- 8:00 AM: Morning briefing (weather, calendars, system stats, task board)
- 1:00 AM: Velocity assessment (process improvements)
Weekly:
- Knowledge base QA review
- Infrastructure security audit
```
### 3. Security Setup (Critical)
This is non-negotiable. Before giving your agent SSH access:
```text
## Security Checklist
1. Pre-push hooks:
- Install TruffleHog or similar secret scanner on ALL repositories
- Block any commit containing hardcoded API keys, tokens, or passwords
2. Local-first Git workflow:
- Use Gitea (self-hosted) for private code before pushing to public GitHub
- CI scanning pipeline (Woodpecker or similar) runs before any public push
- Human review required before main branch merges
3. Defense in depth:
- Dedicated 1Password vault for AI agent (limited scope)
- Network segmentation for sensitive services
- Daily automated security audits checking for:
* Privileged containers
* Hardcoded secrets in code or configs
* Overly permissive file/network access
* Known vulnerabilities in deployed images
4. Agent constraints:
- Branch protection: PR required for main, agent cannot override
- Read-only access where write isn't needed
- All changes logged and auditable via git
```
### 4. Morning Briefing Template
```text
## Daily Briefing Format
Generate and deliver at 8:00 AM:
### Weather
- Current conditions and forecast for [your location]
### Calendars
- Your events today
- Partner's events today
- Conflicts or overlaps flagged
### System Health
- CPU / RAM / Storage across all machines
- Services: UP/DOWN status
- Recent deployments (ArgoCD)
- Any alerts in last 24h
### Task Board
- Cards completed yesterday
- Cards in progress
- Blocked items needing attention
### Highlights
- Notable items from nightly brainstorm
- Emails requiring action
- Upcoming deadlines this week
```
## Key Insights
- **"I can't believe I have a self-healing server now"**: The agent can run SSH, Terraform, Ansible, and kubectl commands to fix infrastructure issues before you even know there's a problem
- **AI will hardcode secrets**: This is the #1 security risk. The agent will happily put an API key inline in code if you don't enforce guardrails. Pre-push hooks and secret scanning are mandatory
- **Local-first Git is essential**: Never let the agent push directly to public repositories. Use a private Gitea instance as a staging area with CI scanning
- **Cron jobs are the real product**: The scheduled automation (health checks, email triage, briefings) provides more daily value than ad-hoc commands
- **Knowledge extraction compounds**: Processing notes, conversation exports, and emails into a structured knowledge base gets more valuable over time — one user extracted 49,079 atomic facts from their ChatGPT history alone
## Inspired By
This use case is based on Nathan's detailed writeup ["Everything I've Done with OpenClaw (So Far)"](https://madebynathan.com/2026/02/03/everything-ive-done-with-openclaw-so-far/), where he describes his OpenClaw agent "Reef" running on a home server with SSH access to all machines, a Kubernetes cluster, 1Password integration, and an Obsidian vault with 5,000+ notes. Reef runs 15 active cron jobs, 24 custom scripts, and has autonomously built and deployed applications including a task management UI. Nathan's hard-won lesson after a Day 1 API key exposure: "AI assistants will happily hardcode secrets. They sometimes don't have the same instincts humans do." His defense-in-depth security setup (TruffleHog pre-push hooks, local Gitea, CI scanning, daily audits) is essential reading for anyone attempting this pattern.
Also referenced on the [OpenClaw Showcase](https://openclaw.ai/showcase), where `@georgedagg_` described a similar pattern: deployment monitoring, log review, configuration fixes, and PR submissions — all while walking the dog.
## Related Links
- [Nathan's Full Writeup](https://madebynathan.com/2026/02/03/everything-ive-done-with-openclaw-so-far/)
- [OpenClaw Documentation](https://github.com/openclaw/openclaw)
- [TruffleHog (Secret Scanning)](https://github.com/trufflesecurity/trufflehog)
- [K3s (Lightweight Kubernetes)](https://k3s.io/)
- [Gitea (Self-hosted Git)](https://gitea.io/)
- [n8n (Workflow Automation)](https://n8n.io/)

70
openclaw/usecases/semantic-memory-search.md Normal file
View File

@@ -0,0 +1,70 @@
# Semantic Memory Search
OpenClaw's built-in memory system stores everything as markdown files — but as memories grow over weeks and months, finding that one decision from last Tuesday becomes impossible. There is no search, just scrolling through files.
This use case adds **vector-powered semantic search** on top of OpenClaw's existing markdown memory files using [memsearch](https://github.com/zilliztech/memsearch), so you can instantly find any past memory by meaning, not just keywords.
## What It Does
- Index all your OpenClaw markdown memory files into a vector database (Milvus) with a single command
- Search by meaning: "what caching solution did we pick?" finds the relevant memory even if the word "caching" does not appear
- Hybrid search (dense vectors + BM25 full-text) with RRF reranking for best results
- SHA-256 content hashing means unchanged files are never re-embedded — zero wasted API calls
- File watcher auto-reindexes when memory files change, so the index is always up to date
- Works with any embedding provider: OpenAI, Google, Voyage, Ollama, or fully local (no API key needed)
## Pain Point
OpenClaw's memory is stored as plain markdown files. This is great for portability and human readability, but it has no search. As your memory grows, you either have to grep through files (keyword-only, misses semantic matches) or load entire files into context (wastes tokens on irrelevant content). You need a way to ask "what did I decide about X?" and get the exact relevant chunk, regardless of phrasing.
## Skills You Need
- No OpenClaw skills required — memsearch is a standalone Python CLI/library
- Python 3.10+ with pip or uv
## How to Set It Up
1. Install memsearch:
```bash
pip install memsearch
```
2. Run the interactive config wizard:
```bash
memsearch config init
```
3. Index your OpenClaw memory directory:
```bash
memsearch index ~/path/to/your/memory/
```
4. Search your memories by meaning:
```bash
memsearch search "what caching solution did we pick?"
```
5. For live sync, start the file watcher — it auto-indexes on every file change:
```bash
memsearch watch ~/path/to/your/memory/
```
6. For a fully local setup (no API keys), install the local embedding provider:
```bash
pip install "memsearch[local]"
memsearch config set embedding.provider local
memsearch index ~/path/to/your/memory/
```
## Key Insights
- **Markdown stays the source of truth.** The vector index is just a derived cache — you can rebuild it anytime with `memsearch index`. Your memory files are never modified.
- **Smart dedup saves money.** Each chunk is identified by a SHA-256 content hash. Re-running `index` only embeds new or changed content, so you can run it as often as you like without wasting embedding API calls.
- **Hybrid search beats pure vector search.** Combining semantic similarity (dense vectors) with keyword matching (BM25) via Reciprocal Rank Fusion catches both meaning-based and exact-match queries.
## Related Links
- [memsearch GitHub](https://github.com/zilliztech/memsearch) — the library powering this use case
- [memsearch Documentation](https://zilliztech.github.io/memsearch/) — full CLI reference, Python API, and architecture
- [OpenClaw](https://github.com/openclaw/openclaw) — the memory architecture that inspired memsearch
- [Milvus](https://milvus.io/) — the vector database backend

118
openclaw/usecases/todoist-task-manager.md Normal file
View File

@@ -0,0 +1,118 @@
# Todoist Task Manager: Agent Task Visibility
Maximize transparency for long-running agentic workflows by syncing internal reasoning and progress logs directly to Todoist.
## Pain Point
When agents run complex, multi-step tasks (like building a full-stack app or performing deep research), the user often loses track of what the agent is currently doing, what steps have been completed, and where the agent might be stuck. Checking chat logs manually is tedious for background tasks.
## What It Does
This use case uses the `todoist-task-manager` skill to:
1. **Visualize State**: Create tasks in specific sections like `🟡 In Progress` or `🟠 Waiting`.
2. **Externalize Reasoning**: Post the agent's internal "Plan" into the task description.
3. **Stream Logs**: Add sub-step completions as comments to the task in real-time.
4. **Auto-Reconcile**: A heartbeat script checks for stalled tasks and notifies the user.
## Skills you Need
You don't need a pre-built skill. Simply prompt your OpenClaw agent to create the bash scripts described in the **Setup Guide** below. Since OpenClaw can manage its own filesystem and execute shell commands, it will effectively "build" the skill for you upon request.
## Detailed Setup Guide
### 1. Configure Todoist
Create a project (e.g., "OpenClaw Workspace") and get its ID. Create sections for different states:
- `🟡 In Progress`
- `🟠 Waiting`
- `🟢 Done`
### 2. Implementation: The "Agent-Built" Skill
Instead of installing a skill, you can ask OpenClaw to create these scripts for you. Each script handles a different part of the communication with the Todoist API.
**`scripts/todoist_api.sh`** (The Core Wrapper):
```bash
#!/bin/bash
# Usage: ./todoist_api.sh <endpoint> <method> [data_json]
ENDPOINT=$1
METHOD=$2
DATA=$3
TOKEN="YOUR_TODOIST_API_TOKEN"
if [ -z "$DATA" ]; then
curl -s -X "$METHOD" "https://api.todoist.com/rest/v2/$ENDPOINT" \
-H "Authorization: Bearer $TOKEN"
else
curl -s -X "$METHOD" "https://api.todoist.com/rest/v2/$ENDPOINT" \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d "$DATA"
fi
```
**`scripts/sync_task.sh`** (Task & Status Management):
```bash
#!/bin/bash
# Usage: ./sync_task.sh <task_content> <status> [task_id] [description] [labels_json_array]
CONTENT=$1
STATUS=$2
TASK_ID=$3
DESCRIPTION=$4
LABELS=$5
PROJECT_ID="YOUR_PROJECT_ID"
case $STATUS in
"In Progress") SECTION_ID="SECTION_ID_PROGRESS" ;;
"Waiting") SECTION_ID="SECTION_ID_WAITING" ;;
"Done") SECTION_ID="SECTION_ID_DONE" ;;
*) SECTION_ID="" ;;
esac
PAYLOAD="{\"content\": \"$CONTENT\""
[ -n "$SECTION_ID" ] && PAYLOAD="$PAYLOAD, \"section_id\": \"$SECTION_ID\""
[ -n "$PROJECT_ID" ] && [ -z "$TASK_ID" ] && PAYLOAD="$PAYLOAD, \"project_id\": \"$PROJECT_ID\""
if [ -n "$DESCRIPTION" ]; then
ESC_DESC=$(echo "$DESCRIPTION" | sed ':a;N;$!ba;s/\n/\\n/g' | sed 's/"/\\"/g')
PAYLOAD="$PAYLOAD, \"description\": \"$ESC_DESC\""
fi
[ -n "$LABELS" ] && PAYLOAD="$PAYLOAD, \"labels\": $LABELS"
PAYLOAD="$PAYLOAD}"
if [ -n "$TASK_ID" ]; then
./scripts/todoist_api.sh "tasks/$TASK_ID" POST "$PAYLOAD"
else
./scripts/todoist_api.sh "tasks" POST "$PAYLOAD"
fi
```
**`scripts/add_comment.sh`** (Progress Logging):
```bash
#!/bin/bash
# Usage: ./add_comment.sh <task_id> <comment_text>
TASK_ID=$1
TEXT=$2
ESC_TEXT=$(echo "$TEXT" | sed ':a;N;$!ba;s/\n/\\n/g' | sed 's/"/\\"/g')
PAYLOAD="{\"task_id\": \"$TASK_ID\", \"content\": \"$ESC_TEXT\"}"
./scripts/todoist_api.sh "comments" POST "$PAYLOAD"
```
### 3. Usage Prompt
You can give this prompt to your agent to both **setup** and **use** the visibility system:
```text
I want you to build a Todoist-based task visibility system for your own runs.
First, create three bash scripts in a 'scripts/' folder:
1. todoist_api.sh (a curl wrapper for Todoist REST API)
2. sync_task.sh (to create or update tasks with specific section_ids for In Progress, Waiting, and Done)
3. add_comment.sh (to post progress logs as comments)
Use these variables for the setup:
- Token: [Your Todoist API Token]
- Project ID: [Your Project ID]
- Section IDs: [In Progress ID, Waiting ID, Done ID]
Once created, for every complex task I give you:
1. Create a task in 'In Progress' with your full PLAN in the description.
2. For every sub-step completion, call add_comment.sh with a log of what you did.
3. Move the task to 'Done' when finished.
```
## Related Links
- [Todoist REST API Documentation](https://developer.todoist.com/rest/v2/)

22
openclaw/usecases/x-account-analysis.md Normal file
View File

@@ -0,0 +1,22 @@
# X Account Analysis
There are many websites designed to give you a qualitative analysis of your X account. While X already gives you an **analytics** section, it's more focused to show your numbers on your performance.
But a qualitative analysis focuses on the quality of your posts, not the performance stats. Some insights you can get from this type of analysis:
- What are the patterns that make my posts go viral?
- What topics I talk about get me most engagement?
- Why do I get posts with 1000+ likes but sometimes posts with <5 likes? What am I doing wrong?
There are many websites and apps designed to give you X analytics, but they focus on the statistics. There are probably 1-2 websites that let you talk with an AI to understand your performance.
But now you can use OpenClaw to do this analysis for you, without needing to pay $10-$50 for subscriptions on these websites.
## Skills you Need
Bird Skill. `clawhub install bird` (it comes pre-bundled)
## How to Set it Up
Here's the flow:
1. Make sure Bird skill is working.
2. For security and isolation, you better create a new account for your ClawdBot.
3. Auth with your X account. log into x.com in Chrome/Brave, and provide the right cookie information (`auth-token`, `ct0`) so OpenClaw can access your account.
4. Ask OpenClaw to take a look at your real account, fetch the last N tweets, and ask it any questions you like. Alternatively, you can ask it to write you specific scripts.

54
openclaw/usecases/x-twitter-automation.md Normal file
View File

@@ -0,0 +1,54 @@
# X/Twitter Automation from Chat
Full X/Twitter automation through natural language — post tweets, reply, like, retweet, follow, DM, search, extract data, run giveaways, and monitor accounts, all from your OpenClaw chat.
## Pain Point
Managing an X/Twitter presence requires jumping between the app, third-party dashboards, and analytics tools. Running giveaways means manual winner picking. Extracting followers, likers, or retweeters requires scraping scripts. There is no single interface that lets you do all of this conversationally.
## What It Does
TweetClaw is an OpenClaw plugin that connects your agent to the X/Twitter API. You interact entirely through chat:
- **Post & engage** — Compose tweets, reply to threads, like, retweet, follow/unfollow, send DMs
- **Search & extract** — Search tweets and users, extract followers, likers, retweeters, quote tweeters, list members
- **Giveaways** — Pick random winners from tweet engagements with configurable filters (minimum followers, account age, keyword requirements)
- **Monitors** — Watch accounts for new tweets or follower changes and get notified
All actions go through a managed API — no browser cookies, no scraping, no credential exposure.
## Prompts
**Install the plugin:**
```text
openclaw plugins install @xquik/tweetclaw
```
**Post a tweet:**
```text
Post a tweet: "Just shipped a new feature — try it out!"
```
**Run a giveaway:**
```text
Pick 3 random winners from the retweeters of this tweet: https://x.com/username/status/123456789. Exclude accounts with fewer than 50 followers.
```
**Extract data:**
```text
Extract all users who liked this tweet and export as CSV: https://x.com/username/status/123456789
```
**Monitor an account:**
```text
Monitor @elonmusk and notify me whenever he posts a new tweet.
```
## Skills Needed
- [@xquik/tweetclaw](https://www.npmjs.com/package/@xquik/tweetclaw) — Install via `openclaw plugins install @xquik/tweetclaw`
## Related Links
- [GitHub Repository](https://github.com/Xquik-dev/tweetclaw)
- [npm Package](https://www.npmjs.com/package/@xquik/tweetclaw)

48
openclaw/usecases/youtube-content-pipeline.md Normal file
View File

@@ -0,0 +1,48 @@
# YouTube Content Pipeline
As a daily YouTube creator, finding fresh, timely video ideas across the web and X/Twitter is time-consuming. Tracking what you've already covered prevents duplicates and helps you stay ahead of trends.
This workflow automates the entire content scouting and research pipeline:
• Hourly cron job scans breaking AI news (web + X/Twitter) and pitches video ideas to Telegram
• Maintains a 90-day video catalog with view counts and topic analysis to avoid re-covering topics
• Stores all pitches in a SQLite database with vector embeddings for semantic dedup (so you never get pitched the same idea twice)
• When you share a link in Slack, OpenClaw researches the topic, searches X for related posts, queries your knowledge base, and creates an Asana card with a full outline
## Skills you Need
- `web_search` (built-in)
- [x-research-v2](https://clawhub.ai) or custom X/Twitter search skill
- [knowledge-base](https://clawhub.ai) skill for RAG
- Asana integration (or Todoist)
- `gog` CLI for YouTube Analytics
- Telegram topic for receiving pitches
## How to Set it Up
1. Set up a Telegram topic for video ideas and configure it in OpenClaw.
2. Install the knowledge-base skill and x-research skill.
3. Create a SQLite database for pitch tracking:
```sql
CREATE TABLE pitches (
id INTEGER PRIMARY KEY,
timestamp TEXT,
topic TEXT,
embedding BLOB,
sources TEXT
);
```
4. Prompt OpenClaw:
```text
Run an hourly cron job to:
1. Search web and X/Twitter for breaking AI news
2. Check against my 90-day YouTube catalog (fetch from YouTube Analytics via gog)
3. Check semantic similarity against all past pitches in the database
4. If novel, pitch the idea to my Telegram "video ideas" topic with sources
Also: when I share a link in Slack #ai_trends, automatically:
1. Research the topic
2. Search X for related posts
3. Query my knowledge base
4. Create an Asana card in Video Pipeline with a full outline
```