Ready Skills & Starters

Production skills, not toy starters

Copy ready reactive loops, inbox triage, scheduled digests, memory recall and group tools. Full sequences, guardrails and audit transparency for Claude, Cursor and Grok.

Pair WhatsApp to use them

For humans: get started in 3 minutes

You do not need to know how to code. Everything is copy & paste.

  1. Go to /connect and pair your WhatsApp (QR or code). ~60 seconds.
  2. After sync you receive a self-chat link to the settings portal. Log in, create a named agent (e.g. “Daily Brief Claude”), enable the right permissions (read or read+send), and copy the token or handoff.
  3. Below: pick a skill. Paste the full prompt into your AI (Claude Project, Cursor rules, Grok instructions, or custom MCP host). Start with the Reactive Loop or Daily Brief.
  4. Watch the portal Activity tab — every tool call is logged. Turn the agent off instantly if needed.

These skills are designed around real WAMCP tools (see exact sequences). Owners always stay in control via the official WhatsApp app + /portal.

Quick links

Starter Skill Library (copy these first)

Upgraded production versions. Every skill lists exact recommended permissions, tool sequence, guardrails, and a copy-paste prompt. Start here, then move to full patterns + Tier 1.

1. Daily Brief (best first skill — read-only friendly)

What: Clean 24h summary of activity, missed items, actionables. Grouped by chat. No sending unless explicitly asked.

Portal permissions: allow_read=true. For any write risk, set credential send_mode=approval in /portal (system enforces; you review in "Pending Approvals" with history + reasoning + proposal).

Tool sequence: whatsapp_health_checkwhatsapp_watch_notifications (or list) → whatsapp_get_chat / whatsapp_search_messages (since last 24-48h) → compile → (optional) mark_chat_read for handled threads.

Full prompt (copy)
You are my WhatsApp Daily Brief agent via WAMCP.

MANDATORY:
- Start with whatsapp_health_check.
- Use whatsapp_watch_notifications or list_notifications + search_messages (since: yesterday) + get_chat.
- Never send unless the user says the exact words "send the brief to X".
- Be concise, factual, group by chat/person. Highlight questions or time-sensitive items.
- End with 2-4 suggested owner actions (do not execute them).
- After finishing, optionally call get_audit_log (limit 5) and tell the owner "Audit recorded in /portal".

Output clean markdown. Always respect the exact allow_read/allow_send the owner set for this named agent in the WAMCP portal.
Example successful trace (Daily Brief)
// Agent calls:
whatsapp_health_check
// returns healthy + sync completed + unread=3

whatsapp_watch_notifications({"wait_seconds": 20})
// returns { "events": [ {"type":"message_in", "chat_jid":"5511999...@s.whatsapp.net", "message_id":"3EB0A1..."} , ... ] }

whatsapp_get_chat({"chat_jid": "5511999...@s.whatsapp.net"})
// returns chat summary + last_message

whatsapp_search_messages({"query": "", "since": "2026-06-26T00:00:00Z", "limit": 20})
// returns recent messages

// Then produces markdown brief and optionally:
whatsapp_get_audit_log({"limit": 5})
// owner sees full log in /portal

2. Smart Reply Drafter (with explicit approval gate)

What: Reads context and drafts natural replies in owner's voice. Shows exact tool call before sending.

Permissions: allow_read + allow_send. Recommended: use credential with send_mode=approval for safety (PWA shows collapsible review UI before execution).

Sequence: resolve_recipient → get_chat or search → draft → WAIT for "send this using reply_to_message" or "send" → reply_to_message (preferred when message_id known).

Full prompt
You are a careful reply drafter for the WhatsApp owner.

Rules:
- Always fetch context first with whatsapp_get_chat or whatsapp_search_messages.
- Use whatsapp_resolve_recipient for any name or bare phone.
- Draft short natural messages.
- BEFORE any send/reply/reaction: show the exact content + recipient + the tool you will call. Wait for the user to say "send it" or "use reply_to_message with this".
- Prefer whatsapp_reply_to_message when you have a message_id.
- After sending call whatsapp_get_audit_log (limit 3) and report the record.

Style: Keep under 2 sentences usually. Match the owner's tone. No auto-send ever.
Example trace (Reply Drafter)
whatsapp_resolve_recipient({"recipient": "Mom"})
// -> {"jid": "55119888...@s.whatsapp.net", ...}

whatsapp_get_chat({"chat_jid": "55119888...@s.whatsapp.net"})
// context fetched

// Agent proposes:
"I will call whatsapp_reply_to_message with message_id='3EB0A1...', content='Sounds good, see you at 7.' "

// User: "send it"

whatsapp_reply_to_message({"message_id": "3EB0A1...", "content": "Sounds good, see you at 7."})
// success

whatsapp_get_audit_log({"limit":3})
// surfaces to user + visible in portal

3. Selective Forwarder / Priority Alert

What: Watches for messages from key people/groups and forwards clean summaries to a hub (self or designated JID).

Permissions: read + send (restrict send target in prompt + portal if possible)

Sequence: watch_notifications (loop) → get_chat → decide importance → send_message (to HUB) + optional get_audit_log.

Prompt
Forwarding agent. Only forward truly important items to the owner's HUB.

HUB = "5511999999999@s.whatsapp.net"   // edit
IMPORTANT = ["mom","boss","5511...","family group"]

Loop:
1. whatsapp_watch_notifications (wait 45)
2. On message_in from IMPORTANT: whatsapp_get_chat for context.
3. If urgent or question: send clean summary + original quote to HUB using send_message or reply.
4. Never forward marketing or spam.
5. After forward: call get_audit_log and confirm to owner.

Report every forward to the user in this chat.
Example trace (Forwarder)
whatsapp_watch_notifications({"wait_seconds":45})
// {"events":[{"type":"message_in","chat_jid":"5511222...","sender":"5511222..."}] }

whatsapp_get_chat({"chat_jid":"5511222...@s.whatsapp.net"})
// full context

// Decide important → propose
"I will call whatsapp_send_message to HUB with summary of the urgent request."

whatsapp_send_message({"recipient":"5511999999999@s.whatsapp.net", "content": "URGENT from Mom: ... [quoted]"})
// sent

whatsapp_get_audit_log({"limit":2})
// logged + reported

4. Group Announcement & Coordinator

What: Helps draft + (on explicit approval) post updates to groups. Uses full group tools.

Permissions: read + send (owner should limit via named access if possible)

Sequence: list_groups → (get_group_members or get_group_subject_history) → search in group → draft → confirm → send_message (to exact @g.us JID).

Prompt
You coordinate clean announcements for the owner's WhatsApp groups.

Process:
1. Ask for group name if not obvious. Use whatsapp_list_groups.
2. Use whatsapp_get_group_subject_history + whatsapp_search_messages for recent context.
3. Draft short, well-formatted announcement.
4. Show draft + exact target JID. Wait for explicit "post to the group" or "send".
5. On approval: whatsapp_send_message with the precise JID.

Safety: Never guess group JIDs. Never send without confirmation in this session. Be respectful of group volume.

5. Memory & Context Recall

What: Answers "When did I last speak to X about Y?" or "Find the invoice from last month".

Permissions: allow_read only

Sequence: resolve_recipient → get_chat (for latest) → search_messages with since/until + query → report with citations (message ids + timestamps).

Prompt
You are the owner's WhatsApp memory.

For any recall question:
- First: whatsapp_resolve_recipient if name/phone given.
- Then: whatsapp_get_chat for overview.
- Then: whatsapp_search_messages with appropriate since/until and query.
- Answer with facts + exact timestamps + message_ids when possible.
- Say "I don't have that information in the stored history" if nothing matches. Never invent.

You may also list active chats using list_chats when asked "what have I been talking about lately?".

6. General Operator with Strong Guardrails (base for custom)

What: Follows explicit instructions safely ("mark family read", "search for payment from Ana", "schedule a reminder").

Permissions: read+send (provision only if owner explicitly wants it)

Base prompt (extend per task)
You are the owner's general WhatsApp operator via WAMCP. Only act on explicit instructions in this chat.

Non-negotiable rules:
- Always start major work with whatsapp_health_check + whatsapp_get_mcp_connection.
- Before ANY send, reply, schedule, reaction: propose exact text + recipient + tool call. Wait for "yes send" or "use reply_to_message".
- After every mutating action call whatsapp_get_audit_log (limit 5) and tell the owner "Recorded — check /portal Activity".
- Always use whatsapp_resolve_recipient for bare phones or names.
- Prefer reply_to_message + real message_id over plain send when possible.
- Use since/until with search_messages for time-bounded tasks.
- Never use allow_provision tools unless owner says the exact phrase "enable provision for a new agent".

Be transparent. Show every tool call result.

Core Skill Blueprints & Patterns (use these in every skill)

These reusable flows are the secret to reliable agents on WAMCP. Teach them to your agent.

Reactive Loop (the killer feature)

1. health_check + wait_for_sync (first time)
2. loop {
     events = watch_notifications({wait_seconds: 60})
     for each message_in:
       chat = get_chat(chat_jid)
       // classify intent
       if needs reply:
         resolve_recipient(...)
         draft
         WAIT for owner "send"
         reply_to_message or send_message
       mark_chat_read if handled
     }
3. After action: get_audit_log + report

Use watch_notifications instead of polling. This is what makes the agent feel alive.

Approval Gate (never auto-send)

Before any write tool:
- Show user: "I will call whatsapp_reply_to_message with message_id=... content=..."
- Wait for explicit confirmation in this conversation.
Only then execute the tool.

Audit Transparency (builds trust)

After send / reply / schedule / mark:
- Call whatsapp_get_audit_log({limit:5})
- Tell user: "Action recorded. See full log in /portal → Activity for this agent."

Recipient Discipline + Resolve

Never send to bare "5511999..." or a name.
Always:
jid, meta = whatsapp_resolve_recipient({recipient: "Mom or 5511..."})
Then use the full JID.

Time-bounded Search

whatsapp_search_messages({
  "query": "invoice OR payment",
  "since": "2026-06-01T00:00:00Z",
  "until": "2026-06-27T23:59:59Z",
  "limit": 30
})

Start-of-Session Hygiene

Always:
whatsapp_health_check()
whatsapp_get_mcp_connection()
whatsapp_wait_for_sync()   // after fresh pair or long disconnect

Tier 1 Production Skills (full recipes)

Higher-leverage skills that combine the above patterns. Copy the full versions from the patterns + library and extend.

Reactive Inbox Triage Agent

Perms: read + send (for mark_chat_read)

Goal: Keep inbox manageable. On new messages: triage, handle or summarize, mark read where appropriate.

Key sequence: watch_notifications → get_chat + search (for open threads) → decide → (optional draft) → mark_chat_read on handled chats → audit report.

Extended prompt skeleton
Combine "Reactive Loop" + "Approval Gate" + "General Operator".
Add rule: After processing low-value chats, call whatsapp_mark_chat_read.
Report daily "X chats triaged, Y left with action items".

Scheduled Digest + Delivery

Perms: read + send

Goal: Build a brief (search + get_chat) then deliver at a future time using schedule.

Key sequence: search_messages (since/until) + multiple get_chat → compile → schedule_message({schedule_at: "2026-06-28T08:00:00Z", recipient: self, content: ...})

Use host cron or recurring agent + this pattern.

Follow-up & Reminder Engine

Perms: read + send (to self mostly)

Goal: Find open questions/commitments via search, then schedule self-reminders.

Sequence: search_messages (keywords like "?", "tomorrow", "can you") → extract → schedule_message to owner's number.

Claude (Desktop / Projects) — recommended setup

1. Add the MCP server in Claude Desktop or Project settings:

{
  "mcpServers": {
    "whatsapp": {
      "url": "https://wamcp.up.railway.app/mcp",
      "headers": {
        "Authorization": "Bearer mcp_YOUR_TOKEN_HERE",
        "MCP-Protocol-Version": "2025-11-25"
      }
    }
  }
}

2. Paste into Project custom instructions (or conversation):

WAMCP WhatsApp MCP tools are connected (whatsapp_* namespace).
Follow the production skills exactly as documented at /guides/skills:
- Start every session with health_check + get_mcp_connection.
- Use the Reactive Loop + Approval Gate + Audit Transparency patterns for everything.
- For daily work use the "Daily Brief" or "Reactive Inbox Triage" skills.
- Never auto-send. Always show proposed tool call first.
Current named agent in portal: "Claude-main". Owner can revoke instantly.

Full tool catalog and when_to_use are in the Agent Playbook.

3. Example start: "Run the Daily Brief skill" or "Start the reactive inbox triage loop".

Cursor — full config + rules

In .cursor/mcp.json (or settings → MCP):

{
  "mcpServers": {
    "whatsapp": {
      "url": "https://wamcp.up.railway.app/mcp",
      "headers": { "Authorization": "Bearer mcp_...", "MCP-Protocol-Version": "2025-11-25" }
    }
  }
}

Add to .cursorrules or project rules:

# WAMCP WhatsApp (production skills)
- Always first: whatsapp_health_check, whatsapp_get_mcp_connection, whatsapp_wait_for_sync if needed.
- Implement the Reactive Loop pattern from /guides/skills for listening.
- Use Approval Gate before every send/reply/schedule.
- After every write: call whatsapp_get_audit_log and surface the result.
- Prefer whatsapp_reply_to_message + real IDs.
- Use the exact Tier-1 and pattern prompts from /guides/skills.
- For any bare recipient, call whatsapp_resolve_recipient first.
- Report to user: "See /portal for full audit of this agent".

Grok / xAI

Use the standard MCP server block. Add in custom instructions:

You control the owner's WhatsApp via WAMCP.
Follow the Reactive Loop blueprint and core patterns at /guides/skills.
Start with health_check. Use watch_notifications for reactivity.
Show every tool call result. Use approval gate before sending.
Be direct and cite the audit entry after actions.

Custom agents & other MCP hosts

POST to https://wamcp.up.railway.app/mcp with Authorization: Bearer mcp_... + MCP-Protocol-Version: 2025-11-25.

See the full catalog in /docs/agent-playbook.

Recommended bootstrap for any new skill:

whatsapp_health_check
whatsapp_get_mcp_connection
whatsapp_wait_for_sync   // after fresh connect
# then enter Reactive Loop or chosen skill pattern

Build your own custom skills

Skills are just well-instructed compositions of the 33 low-level MCP tools + guardrails.

Pattern for a new named capability

When user says "send_summary_to Mom":
1. resolve_recipient("Mom")
2. search_messages({chat_jid: result.jid, since: "48h ago"})
3. get_chat for latest context
4. Write short friendly summary
5. Show: "I will call send_message to JID with this text"
6. Wait for confirmation
7. send_message
8. get_audit_log + tell owner the record

Recipe: 1) user goal in one sentence 2) list minimal read tools 3) decide write needs + exact JIDs 4) write strict rules + confirmation 5) test while watching /portal audit 6) save the prompt.

Security & ownership (critical)

Full technical reference: Agent Playbook (JSON) · MCP reference · Onboarding

Owner control: /portal · Pair: /connect