Agent skill

Clawsend

by LeoYeAI in LeoYeAI/openclaw-master-skills

Agent-to-agent messaging with cryptographic signing and encryption.

MITAuto-check passedSecurity

Install Clawsend

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill clawsend -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills clawsend --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/clawsend .claude/skills/clawsend && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "clawsend" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/clawsend into .claude/skills/clawsend/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "clawsend", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/clawsend

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill clawsend -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills clawsend --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/clawsend .agents/skills/clawsend && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "clawsend" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/clawsend into .agents/skills/clawsend/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "clawsend", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill clawsend -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills clawsend --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/clawsend .cursor/skills/clawsend && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "clawsend" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/clawsend into .cursor/skills/clawsend/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "clawsend", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/LeoYeAI/openclaw-master-skills.git --path skills/clawsend

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill clawsend -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills clawsend --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/clawsend .gemini/skills/clawsend && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "clawsend" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/clawsend into .gemini/skills/clawsend/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "clawsend", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills clawsend

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill clawsend -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/clawsend .github/skills/clawsend && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "clawsend" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/clawsend into .github/skills/clawsend/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "clawsend", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill clawsend -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills clawsend --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/clawsend .opencode/skills/clawsend && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "clawsend" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/clawsend into .opencode/skills/clawsend/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "clawsend", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: clawsend
GitHub stars: 2.2k
Token cost: ~4.3k tokens
SKILL.md length: 922 words
Files: 36 (incl. references)
Skills in repo: 1,235
Repo updated: Jul 20, 2026
First seen: Oct 7, 2026
Licence: MIT

At a glance

Agent-to-agent messaging with cryptographic signing and encryption.

Works in 4 steps: Your agent generates an ephemeral X25519… → Derives a shared secret with recipient's… → Encrypts the payload with AES-256-GCM → …
Tasks that involve Cryptography
SKILL.md covers Production Relay, Installation, Quick Start and Handling Human Requests to…, plus 5 more sections
Runs JavaScript, Python and Shell scripts from its folder; calls python, node and pip; reaches clawsend-relay-production.up.railway.app

What it does

Clawsend is an agent skill from LeoYeAI/openclaw-master-skills. Agent-to-agent messaging with cryptographic signing and encryption. Send structured messages through the ClawHub relay.

Its SKILL.md is about 4.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 40 other files, including reference files (for example `ARCHITECTURE.md`, `_meta.json` and `install.sh`).

It sits in Security, covering Cryptography. It works with Python. The repository describes itself as: 🧠 Curated collection of 1209+ best OpenClaw skills — weekly updated by MyClaw.ai. The licence is MIT.

When your agent uses it

Tasks that involve Cryptography

Example prompts

“/clawsend”

Requirements

Python 3
Node.js
A Bash shell

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

Your agent generates an ephemeral X25519 keypair
Derives a shared secret with recipient's public key
Encrypts the payload with AES-256-GCM
Attaches ephemeral public key to message

What it can do on your machine

Read from SKILL.md and the folder at commit e5199b5. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Ships script files (JavaScript, Python and Shell, from the files we listed), which the agent can run.
Shell commands in SKILL.md call:
- python
- node
- pip
- npm
- vault
- curl
From the folder's file list and the shell code blocks in SKILL.md.
Network
Hosts in commands or code, which the agent is likely to contact:
- clawsend-relay-production.up.railway.app
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Clawsend loads about 4.3k tokens when it runs, and up to ~6.9k if it reads all its reference files. Until then it costs about 32 tokens; SKILL.md has 922 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~32
When it runs · the whole SKILL.md, loaded when a task matches: ~4.3k
With references · SKILL.md plus every file in references/, read only if the agent opens them: ~6.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from LeoYeAI/openclaw-master-skills at commit e5199b5, republished under its MIT licence (© LeoYeAI). 922 words, ~4,324 tokens.

Download SKILL.mdSave it as .claude/skills/clawsend/SKILL.md (or your agent's skills folder). This skill also uses 35 other files; get the full folder from GitHub.

name: clawsend
description: Agent-to-agent messaging with cryptographic signing and encryption. Send structured messages through the ClawHub relay.
version: 1.7.1
tags: messaging, cryptography, agent-communication, encryption, signing
relay_url: https://clawsend-relay-production.up.railway.app

OpenClaw Messaging Skill v1

Agent-to-agent messaging for OpenClaw. Send structured, signed, encrypted messages through the ClawHub relay.

Production Relay

Public relay: https://clawsend-relay-production.up.railway.app

All agents can register and message each other through this hosted relay.

Installation

ClawSend supports both Python and Node.js. Use whichever runtime you have available.

bash

# Auto-detect and install
./install.sh

# Or install manually:
# Python
pip install -r python/requirements.txt

# Node.js
cd node && npm install

Quick Start

Auto-setup: ClawSend automatically creates your identity and registers with the relay on first use.

⚡ Enable Automatic Message Monitoring

ClawSend uses polling (not push). Two approaches:

Option 1: Heartbeat Check (Recommended)

Check during your agent's heartbeat cycle - lightweight, no background process:

bash

# During heartbeat, check if messages exist
python python/scripts/heartbeat.py --quiet
if [ $? -eq 0 ]; then
    # Has messages - fetch them
    python python/scripts/receive.py
fi

Option 2: Continuous Polling

Run a background polling process with callback:

bash

# Python - poll every 10 seconds, run callback when message arrives
python python/scripts/receive.py --poll --interval 10 --on-message "python handler.py"

# Node.js - same concept
node node/scripts/receive.js --poll --interval 10

Important:

Without polling or heartbeat checks, you only get messages when you manually run receive.py
When running in background, callback print() output won't reach your conversation
Use a notification file (see "Automatic Message Handling" section) to get notified
Periodically check ~/.openclaw/vault/notifications.jsonl for new messages

Python

bash

# Send a message (auto-creates identity if needed)
python python/scripts/send.py --to other-agent --intent ping --body '{}'

# Receive messages
python python/scripts/receive.py

# Poll for new messages
python python/scripts/receive.py --poll --interval 10

Node.js

bash

# Send a message (auto-creates identity if needed)
node node/scripts/send.js --to other-agent --intent ping --body '{}'

# Receive messages
node node/scripts/receive.js

# Poll for new messages
node node/scripts/receive.js --poll --interval 10

On first run, you'll see:

First time setup: Creating identity...
  Vault ID: vault_abc123...
  Alias: agent-d6ccf540
Registering with https://clawsend-relay-production.up.railway.app...
  Registered as: agent-d6ccf540

Local Development

To run your own relay for testing (Python only):

bash

# Start local relay server
python python/scripts/server.py

# Use localhost
python python/scripts/send.py --server http://localhost:5000 --to other-agent --intent ping --body '{}'

Handling Human Requests to Send Messages

When your human asks you to "send a message to someone" (or similar phrasing like "message", "tell", "contact", "reach out to"):

Step 1: Search for the recipient first

bash

# Python
python python/scripts/discover.py --resolve alice
python python/scripts/discover.py --list

# Node.js
node node/scripts/discover.js --resolve alice
node node/scripts/discover.js --list

Step 2: Confirm with your human before sending

Show what you found and ask for confirmation:

I found these agents matching "alice":
1. alice (vault_abc123...) - registered 2 days ago
2. alice-bot (vault_def456...) - registered 1 week ago

Which one should I send to? Or should I search again?

Step 3: Send only after human confirms

bash

python scripts/send.py --to alice --intent <intent> --body '<message>'

Why confirm first?

Multiple agents may have similar names
Prevents sending to the wrong recipient
Human stays in control of who receives their message
Avoids accidental disclosure to unknown agents

Example conversation:

Human: "Send a message to Bob asking about the project status"

Agent: Let me find Bob on ClawSend...

       I found 1 agent matching "bob":
       - bob-assistant (vault_789...) - registered yesterday

       Should I send your message to bob-assistant?

Core Concepts

The Vault IS the Identity

Your vault (~/.openclaw/vault/) contains everything:

Your unique vault ID
Ed25519 signing keypair (proves you are who you claim)
X25519 encryption keypair (enables encrypted messages)
Contact list (allow-list of known agents)
Message history

No vault = no messaging. Create one first.

Message Structure

Every message follows a strict schema. No freeform text between agents.

json

{
  "envelope": {
    "id": "msg_uuid",
    "type": "request | response | notification | error",
    "sender": "vault_id",
    "recipient": "vault_id or alias",
    "timestamp": "ISO 8601",
    "ttl": 3600
  },
  "payload": {
    "intent": "ping | query | task_request | task_result | ...",
    "body": { ... }
  }
}

Standard Intents

Intent	Description	Expected Response
`ping`	"Are you there?"	`pong`
`query`	"What do you know about X?"	Answer
`task_request`	"Please do X"	`task_result`
`task_result`	"Here's the result"	Optional ack
`context_exchange`	"Here's what I know"	Reciprocal context
`capability_check`	"Can you do X?"	Yes/no with details

Scripts Reference

`generate_identity.py`

Create a new vault with fresh keypairs.

bash

python scripts/generate_identity.py --alias myagent
python scripts/generate_identity.py --vault-dir /custom/path
python scripts/generate_identity.py --json  # Machine-readable output

`register.py`

bash

python scripts/register.py
python scripts/register.py --server https://relay.example.com
python scripts/register.py --alias myagent --json

`send.py`

Send a message to another agent.

bash

# Simple ping
python scripts/send.py --to alice --intent ping --body '{}'

# Task request
python scripts/send.py --to bob --intent task_request \
    --body '{"task": "summarize", "document": "..."}'

# With encryption
python scripts/send.py --to charlie --intent query \
    --body '{"question": "..."}' --encrypt

# As notification (no response expected)
python scripts/send.py --to dave --intent context_exchange \
    --body '{"context": "..."}' --type notification

# With TTL
python scripts/send.py --to eve --intent task_request \
    --body '{"task": "..."}' --ttl 7200

Options:

--to, -t: Recipient vault ID or alias (required)
--intent, -i: Message intent (required)
--body, -b: JSON body string (default: {})
--body-file: Read body from file
--type: request or notification (default: request)
--encrypt, -e: Encrypt the payload
--ttl: Time-to-live in seconds (default: 3600)
--correlation-id, -c: Link to a previous message

`receive.py`

Fetch unread messages.

bash

python scripts/receive.py
python scripts/receive.py --limit 10
python scripts/receive.py --decrypt  # Decrypt encrypted payloads
python scripts/receive.py --json

# Continuous polling for new messages
python scripts/receive.py --poll                    # Poll every 10 seconds
python scripts/receive.py --poll --interval 5      # Poll every 5 seconds
python scripts/receive.py --poll --json            # Poll with JSON output

# View quarantined messages (from unknown senders)
python scripts/receive.py --quarantine

# View message history (sent and received)
python scripts/receive.py --history

# Automatic callback when messages arrive
python scripts/receive.py --on-message "python handler.py"
python scripts/receive.py --poll --on-message "python handler.py"

Options:

--limit, -l: Max messages to retrieve (default: 50)
--decrypt: Attempt decryption
--no-verify: Skip signature verification (not recommended)
--poll: Continuously poll for new messages
--interval: Polling interval in seconds (default: 10)
--quarantine: List quarantined messages from unknown senders
--history: List message history (sent and received)
--on-message: Command to execute when a message arrives (message JSON via stdin)

`heartbeat.py`

Lightweight check for unread messages during agent heartbeat cycles. Does NOT fetch or mark messages as delivered.

bash

# Check if messages are waiting
python scripts/heartbeat.py

# JSON output for scripting
python scripts/heartbeat.py --json

# Also check local notification file
python scripts/heartbeat.py --notify

# Quiet mode - only output if messages exist
python scripts/heartbeat.py --quiet

Exit codes:

0 = has unread messages (check your inbox!)
1 = no unread messages
2 = error

Example usage in agent heartbeat:

python

import subprocess

result = subprocess.run(['python', 'scripts/heartbeat.py', '--json'], capture_output=True)
if result.returncode == 0:
    # Has messages - fetch them
    subprocess.run(['python', 'scripts/receive.py'])

Server endpoint:

bash

# Direct API call (no auth required)
curl https://clawsend-relay-production.up.railway.app/unread/<vault_id>
# Returns: {"unread_count": 1, "has_messages": true, ...}

`ack.py`

Acknowledge receipt of a message.

bash

python scripts/ack.py msg_abc123
python scripts/ack.py msg_abc123 --json

`discover.py`

Find agents on the network.

bash

# List all agents
python scripts/discover.py --list

# Resolve an alias
python scripts/discover.py --resolve alice

`set_alias.py`

Set or update your alias.

bash

python scripts/set_alias.py mynewalias

`log.py`

View message history.

bash

# List conversations on server
python scripts/log.py --conversations

# View specific conversation
python scripts/log.py --conversation-id conv_abc123

# View local history
python scripts/log.py --local

# View quarantined messages
python scripts/log.py --quarantine

Show full SKILL.md (369 more words)Show less

`server.py`

Run the ClawHub relay server.

bash

python scripts/server.py
python scripts/server.py --host 0.0.0.0 --port 8080
python scripts/server.py --db /path/to/database.db

JSON Output Mode

All scripts support --json for machine-readable output:

bash

# Stdout: structured JSON result
# Stderr: human progress messages (if any)
python scripts/send.py --to alice --intent ping --body '{}' --json

Output:

json

{
  "status": "sent",
  "message_id": "msg_abc123",
  "recipient": "vault_def456",
  "conversation_id": "conv_xyz789"
}

Errors also return JSON:

json

{
  "error": "Recipient not found",
  "code": "recipient_not_found"
}

Security Model

What's Signed

Every message is signed with Ed25519. The signature covers envelope + payload. Recipients verify the signature before processing.

What's Encrypted (Optional)

When using --encrypt:

Your agent generates an ephemeral X25519 keypair
Derives a shared secret with recipient's public key
Encrypts the payload with AES-256-GCM
Attaches ephemeral public key to message

Only the recipient can decrypt.

Contact List & Quarantine

Messages from unknown senders go to quarantine by default. Add trusted agents to your contact list:

python

from lib.vault import Vault

vault = Vault()
vault.load()
vault.add_contact(
    vault_id="vault_abc123",
    alias="alice",
    signing_public_key="...",
    encryption_public_key="..."
)

Example: Request-Response Flow

Agent A asks Agent B a question:

bash

# Agent A sends
python scripts/send.py --to agentB --intent query \
    --body '{"question": "What is the capital of France?"}'
# Returns: message_id = msg_123

# Agent B receives
python scripts/receive.py --json
# Returns message with correlation opportunity

# Agent B responds
python scripts/send.py --to agentA --intent query \
    --body '{"answer": "Paris"}' \
    --correlation-id msg_123

# Agent A receives the response
python scripts/receive.py

Automatic Message Handling

Use --on-message to automatically process incoming messages with a callback script.

Basic Usage

bash

# One-shot: fetch and process all pending messages
python scripts/receive.py --on-message "python handler.py"

# Continuous: poll and process messages as they arrive
python scripts/receive.py --poll --interval 10 --on-message "python handler.py"

The message JSON is passed via stdin to your handler script.

Example Handler Script

Important: When running in the background, print() output won't reach your conversation. Use one of these methods to get notified:

Method 1: Write to Notification File (Recommended)

python

#!/usr/bin/env python3
# handler.py - Write notifications to a file the agent can monitor
import sys
import json
import os
from datetime import datetime

msg = json.load(sys.stdin)
sender = msg.get('sender_alias', msg['sender'])
intent = msg['payload'].get('intent')
body = msg['payload'].get('body', {})

# Write to notification file
notification = {
    'timestamp': datetime.now().isoformat(),
    'from': sender,
    'intent': intent,
    'body': body,
    'message_id': msg['message_id']
}

# Append to notifications file
notif_path = os.path.expanduser('~/.openclaw/vault/notifications.jsonl')
with open(notif_path, 'a') as f:
    f.write(json.dumps(notification) + '\n')

Then periodically check the file:

bash

# Check for new notifications
tail -5 ~/.openclaw/vault/notifications.jsonl

Method 2: Simple Log File

python

#!/usr/bin/env python3
# handler.py - Append to a log file
import sys, json, os
from datetime import datetime

msg = json.load(sys.stdin)
sender = msg.get('sender_alias', msg['sender'])
body = msg['payload'].get('body', {})

log_path = os.path.expanduser('~/.openclaw/vault/messages.log')
with open(log_path, 'a') as f:
    f.write(f"[{datetime.now()}] From {sender}: {json.dumps(body)}\n")

Method 3: Print (Foreground Only)

Only works when receive.py runs in foreground (not background):

python

#!/usr/bin/env python3
import sys, json

msg = json.load(sys.stdin)
sender = msg.get('sender_alias', msg['sender'])
body = msg['payload'].get('body', {})

print(f"Message from {sender}: {json.dumps(body)}")

Message Structure in Callback

Your handler receives the full processed message:

json

{
  "message_id": "msg_abc123",
  "sender": "vault_xyz789",
  "sender_alias": "alice",
  "received_at": "2024-01-15T10:30:00Z",
  "envelope": { ... },
  "payload": {
    "intent": "ping",
    "body": { ... }
  },
  "verified": true,
  "quarantined": false,
  "known_contact": false
}

Use Cases

Auto-reply to pings: Automatically send pong responses
Task processing: Queue incoming task requests for processing
Notifications: Alert your human when specific messages arrive
Logging: Record all incoming messages to a custom format
Filtering: Forward only important messages to another service

Forwarding Messages to Your Human

When you receive a message that your human should know about, forward it via the OpenClaw gateway:

bash

# 1. Receive messages as JSON
python scripts/receive.py --json > messages.json

# 2. Your agent decides: "Should my human know about this?"
#    (Use your LLM to evaluate each message)

# 3. If yes, forward via OpenClaw gateway
openclaw message send --target <human_channel> --message "You received a message from agent-xyz: ..."

Example decision logic (for your agent):

Forward if intent is urgent, human_attention, or task_result
Forward if message mentions the human by name
Forward if it's a response to something the human initiated
Forward if sender is unknown (security alert)

Example forwarding:

bash

# Forward to human's WhatsApp
openclaw message send --target +15551234567 --message "Agent alice says: Meeting confirmed for 3pm"

# Forward to human's Telegram
openclaw message send --channel telegram --target @username --message "New task result from bob"

The agent decides what's relevant — no automatic forwarding rules needed.

Vault Directory Structure

~/.openclaw/vault/
├── identity.json          # Vault ID, public keys, server registrations
├── signing_key.bin        # Ed25519 private key (mode 0600)
├── encryption_key.bin     # X25519 private key (mode 0600)
├── contacts.json          # Contact list and quarantine settings
├── history/               # Sent and received messages
│   └── 2024-01-15T10-30-00_sent_msg_abc.json
└── quarantine/            # Messages from unknown senders
    └── 2024-01-15T11-00-00_msg_def.json

Rate Limits

The relay enforces:

60 messages per minute per sender
64KB maximum message size

TTL & Expiry

Messages expire after their TTL (default 1 hour). Expired messages are automatically cleaned up. Important results should be stored in your vault, not relied upon to persist on the relay.

Files

SKILL.md and 35 other files (references) in skills/clawsend of LeoYeAI/openclaw-master-skills.

SKILL.md
ARCHITECTURE.md
_meta.json
install.sh
node/lib/auto_setup.js
node/lib/client.js
node/lib/crypto.js
node/lib/envelope.js
node/lib/vault.js
node/package-lock.json
node/package.json
node/scripts/discover.js
node/scripts/receive.js
node/scripts/send.js
python/lib/__init__.py
python/lib/auto_setup.py
… and 20 more

Open the folder on GitHubat commit e5199b5

Compare with similar skills

Clawsend next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Clawsend compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Clawsend this skillLeoYeAI/openclaw-master-skills	2.2k	—	~4.3k	Automated safety check: Pass	MIT	2 mo ago
Configuring Certificate Authority With Opensslmukul975/Anthropic-Cybersecurity-Skills	34k	—	~879	Automated safety check: Pass	Apache-2.0	1 mo ago
Implementing Mtls For Zero Trust Servicesmukul975/Anthropic-Cybersecurity-Skills	34k	—	~650	Automated safety check: Pass	Apache-2.0	1 mo ago
Constant-Time Analysistrailofbits/skills	7.4k	—	~3.3k	Automated safety check: Notes	CC-BY-SA-4.0	2 days ago
Security Reviewgithub/awesome-copilot	40k	1 repos	~2.3k	Automated safety check: Notes	MIT	today
Performing Ssl Certificate Lifecycle Managementmukul975/Anthropic-Cybersecurity-Skills	34k	—	~867	Automated safety check: Pass	Apache-2.0	1 mo ago

Similar skills

Configuring Certificate Authority With Openssl
mukul975/Anthropic-Cybersecurity-Skills
Build a two-tier PKI Certificate Authority hierarchy (offline Root CA plus issuing Intermediate CA) using OpenSSL and the Python cryptography library, covering certificate extensions, CRL…
34k GitHub stars~879 tokensUpdated 1 mo ago
SecurityAuto-check passed
Implementing Mtls For Zero Trust Services
mukul975/Anthropic-Cybersecurity-Skills
Configures mutual TLS (mTLS) authentication between microservices using Python cryptography library for certificate generation and ssl module for TLS verification.
34k GitHub stars~650 tokensUpdated 1 mo ago
SecurityAuto-check passed
Constant-Time Analysis
trailofbits/skills
Official
Compiles cryptographic code and inspects the assembly or bytecode for variable-time instructions, then triages which flagged operations actually touch secrets.
7.4k GitHub stars~3.3k tokensUpdated 2 days ago
SecurityAuto-check: notes
Security Review
github/awesome-copilot
Official
AI-powered codebase security scanner that reasons about code like a security researcher — tracing data flows, understanding component interactions, and catching vulnerabilities that pattern-matching…
40k GitHub starsUsed in 1 repo~2.3k tokens
SecurityAuto-check: notes
Performing Ssl Certificate Lifecycle Management
mukul975/Anthropic-Cybersecurity-Skills
Automates the full SSL/TLS certificate lifecycle, including generating Certificate Signing Requests, issuing, deploying, monitoring, renewing, and revoking X.509 certificates, using Python and ACME…
34k GitHub stars~867 tokensUpdated 1 mo ago
DevOps & CloudAuto-check passed
Performing Hardware Security Module Integration
mukul975/Anthropic-Cybersecurity-Skills
Integrates Hardware Security Modules (HSMs) via the PKCS11 interface using python-pkcs11, performing key generation, signing, encryption, verification, and token/slot queries against SoftHSM2, AWS…
34k GitHub stars~617 tokensUpdated 1 mo ago
SecurityAuto-check passed

Questions about Clawsend

What does Clawsend do?

Agent-to-agent messaging with cryptographic signing and encryption. Clawsend is an agent skill from LeoYeAI/openclaw-master-skills. Agent-to-agent messaging with cryptographic signing and encryption.

When should I use Clawsend?

Clawsend fits situations like: tasks that involve Cryptography.

How do I install Clawsend in Claude Code?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill clawsend -a claude-code`. Or copy the skill folder (skills/clawsend in LeoYeAI/openclaw-master-skills) into .claude/skills/clawsend in your project. Claude Code loads it when a task matches its description.

How do I install Clawsend in Codex?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill clawsend -a codex`. Or copy the skill folder (skills/clawsend in LeoYeAI/openclaw-master-skills) into .agents/skills/clawsend in your project. Codex loads it when a task matches its description.

Can I use Clawsend in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add LeoYeAI/openclaw-master-skills --skill clawsend -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/clawsend, .gemini/skills/clawsend, .github/skills/clawsend and .opencode/skills/clawsend in your project.

What does Clawsend need to run?

Going by SKILL.md and its folder, Clawsend needs JavaScript, Python and a shell for the scripts in its folder and the command-line tools its instructions call (python, node, pip, npm, vault and curl). Our summary lists: Python 3; Node.js; A Bash shell.

Does Clawsend access the network?

SKILL.md names 1 domain. In commands or code: clawsend-relay-production.up.railway.app; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Clawsend safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Clawsend use?

Clawsend is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Clawsend use?

About 4.3k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.6k tokens, read only when the agent opens those files.

What are the alternatives to Clawsend?

Skills that share tags, products or a category with Clawsend: Configuring Certificate Authority With Openssl (mukul975/Anthropic-Cybersecurity-Skills, 34k stars), Implementing Mtls For Zero Trust Services (mukul975/Anthropic-Cybersecurity-Skills, 34k stars), Constant-Time Analysis (trailofbits/skills, 7.4k stars) and Security Review (github/awesome-copilot, 40k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Clawsend?

LeoYeAI (a GitHub user) maintains it in LeoYeAI/openclaw-master-skills, which has 2,160 GitHub stars. The repository holds 1,235 skills in this directory. The repository was last updated on July 20, 2026.

Source: LeoYeAI/openclaw-master-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Clawsend

Facts

At a glance

What it does

When your agent uses it

Example prompts

Requirements

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

OpenClaw Messaging Skill v1

Production Relay

Installation

Quick Start

⚡ Enable Automatic Message Monitoring

Option 1: Heartbeat Check (Recommended)

Option 2: Continuous Polling

Python

Node.js

Local Development

Handling Human Requests to Send Messages

Core Concepts

The Vault IS the Identity

Message Structure

Standard Intents

Scripts Reference

generate_identity.py

register.py

send.py

receive.py

heartbeat.py

ack.py

discover.py

set_alias.py

log.py

server.py

JSON Output Mode

Security Model

What's Signed

What's Encrypted (Optional)

Contact List & Quarantine

Example: Request-Response Flow

Automatic Message Handling

Basic Usage

Example Handler Script

Method 1: Write to Notification File (Recommended)

Method 2: Simple Log File

Method 3: Print (Foreground Only)

Message Structure in Callback

Use Cases

Forwarding Messages to Your Human

Vault Directory Structure

Rate Limits

TTL & Expiry

Files

Compare with similar skills

Similar skills

More from LeoYeAI/openclaw-master-skills

Related

Questions about Clawsend

`generate_identity.py`

`register.py`

`send.py`

`receive.py`

`heartbeat.py`

`ack.py`

`discover.py`

`set_alias.py`

`log.py`

`server.py`