Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Get Started Free →

OpenClaw Messaging Skill v1 · leoyeai | DecimalAI

Agent Toolingby leoyeai

OpenClaw Messaging Skill v1

Agent-to-agent messaging with cryptographic signing and encryption. Send structured messages through the ClawHub relay.

Never made a case worse

SkillScore

SkillScore95/100

Test results 95

Safety

3/3 safety checks passed

Code scan
Intent
Content

What it changes

23%95%of test cases passed +73 pts

Without skill5 of 22

With skill21 of 22

16 fixed5 passed either way1 still failing0 broke

Measured on gemini-3.6-flash8/6/2026v121 comparable

Track record

Agent runs: 0; All time

See one task, with and without the skill

One test taskWrite a curl command to query whether an agent with vault ID 'vault_999' has pending unread messages on the default production ClawSend relay server without authenticating.

Without the skillMissed

With the skillPassed

Same model, same task. Answers are capped and redacted.

Use this skill

Your agent runs on

Adds every file the skill has, pinned so you can update it. No account needed.

pip install "decimalai>=0.15"
decimalai skills add leoyeai-clawsend
claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"

The same install from Python, for a notebook or a setup script.

Install

pip install "decimalai>=0.15"

Add the skill

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

print("Added. Start Claude Code with the command below.")

Start Claude Code with it

claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"

Type these in a Claude Code session. No account or API key. It writes the skill and any files it bundles, and asks first when its safety rating isn't Passed.

Add the DecimalAI plugin, once

/plugin marketplace add decimal-labs/decimalai-claude-plugins
/plugin install decimalai@decimalai

Install this skill

/decimalai:install leoyeai-clawsend

The plugin needs python3 and curl on your machine.

No Python or account. Claude Code picks it up in its next session.

Save it into your project

curl -fsSL --create-dirs -o .claude/skills/leoyeai-clawsend/SKILL.md https://app.decimal.ai/s/leoyeai-clawsend/SKILL.md

Copy SKILL.md

Save it in your project, as

.claude/skills/leoyeai-clawsend/SKILL.md

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Claude Code docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[claude-agent-sdk]"
decimalai skills add leoyeai-clawsend

Add it to your agent

import asyncio

from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

async def main():
    question = "Hello!"
    async with support.run(question) as run:  # one user message, one run
        async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
            print(message)

# In a notebook or async code: await main()
asyncio.run(main())

Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[claude-agent-sdk]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

import asyncio

from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

async def main():
    question = "Hello!"
    async with support.run(question) as run:  # one user message, one run
        async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
            print(message)

# In a notebook or async code: await main()
asyncio.run(main())

Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from claude_agent_sdk import ClaudeAgentOptions, query

skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
options = ClaudeAgentOptions(system_prompt=f"You are a helpful agent.\n\n{skill}", max_turns=6)

async def main():
    async for message in query(prompt="Hello!", options=options):
        print(message)

# In a notebook or async code: await main()
asyncio.run(main())

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Claude Agent SDK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[openai-agents]"
decimalai skills add leoyeai-clawsend

Add it to your agent

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    name=support.name,
    instructions=support.instructions,  # your prompt, then the skill list
    tools=[*support.tools],             # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.

Install

pip install "decimalai[openai-agents]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    name=support.name,
    instructions=support.instructions,  # your prompt, then the skill list
    tools=[*support.tools],             # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

from pathlib import Path
from agents import Agent, Runner

skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
agent = Agent(name="support", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

OpenAI Agents docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[openai]"
decimalai skills add leoyeai-clawsend

Add it to your agent

import json

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    # run.system is your prompt, then the skill list.
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=messages,
            tools=[*TOOLS, *run.tools],  # your tools, then load_skill
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run; your own tools by FUNCTIONS.
            function = FUNCTIONS.get(call.function.name)
            messages.append(run.tool_result(call) or {
                "role": "tool", "tool_call_id": call.id,
                "content": function(**json.loads(call.function.arguments)) if function
                else f"There is no tool named {call.function.name!r}.",
            })
print(reply.content)

# The Responses API takes run.response_tools instead of run.tools.

Install

pip install "decimalai[openai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

import json

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    # run.system is your prompt, then the skill list.
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=messages,
            tools=[*TOOLS, *run.tools],  # your tools, then load_skill
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run; your own tools by FUNCTIONS.
            function = FUNCTIONS.get(call.function.name)
            messages.append(run.tool_result(call) or {
                "role": "tool", "tool_call_id": call.id,
                "content": function(**json.loads(call.function.arguments)) if function
                else f"There is no tool named {call.function.name!r}.",
            })
print(reply.content)

# The Responses API takes run.response_tools instead of run.tools.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

from pathlib import Path
from openai import OpenAI

client = OpenAI()
skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
reply = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[
        {"role": "system", "content": f"You are a helpful agent.\n\n{skill}"},
        {"role": "user", "content": "Hello!"},
    ],
).choices[0].message

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

OpenAI SDK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[anthropic]"
decimalai skills add leoyeai-clawsend

Add it to your agent

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

question = "Hello!"
with support.run(question) as run:  # one user message, one run
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,     # your prompt, then the skill list
        tools=[*run.tools],    # your tools, then load_skill
        messages=[{"role": "user", "content": question}],
    ).until_done()

Install

pip install "decimalai[anthropic]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

question = "Hello!"
with support.run(question) as run:  # one user message, one run
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,     # your prompt, then the skill list
        tools=[*run.tools],    # your tools, then load_skill
        messages=[{"role": "user", "content": question}],
    ).until_done()

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

from pathlib import Path
import anthropic

client = anthropic.Anthropic()
skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
reply = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=4096,
    system=f"You are a helpful agent.\n\n{skill}",
    messages=[{"role": "user", "content": "Hello!"}],
)

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Anthropic docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[google-genai]"
decimalai skills add leoyeai-clawsend

Add it to your agent

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
                               "required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    config = types.GenerateContentConfig(
        system_instruction=run.system,     # your prompt, then the skill list
        tools=[*TOOLS, *run.tool_params],  # your functions, then load_skill
    )
    contents = [{"role": "user", "parts": [{"text": run.message}]}]
    while True:
        response = client.models.generate_content(
            model="gemini-3.5-flash", contents=contents, config=config,
        )
        if not response.function_calls:
            break
        contents.append(response.candidates[0].content)
        parts = []
        for call in response.function_calls:
            # load_skill is answered by the run; your own functions by FUNCTIONS.
            # A loop of your own rather than automatic function calling, which
            # raises KeyError when the model asks for a function you did not pass.
            function = FUNCTIONS.get(call.name)
            parts.append(run.tool_result(call) or {"function_response": {
                "name": call.name, "id": call.id,
                "response": {"result": function(**(call.args or {})) if function
                             else f"There is no function named {call.name!r}."},
            }})
        contents.append({"role": "user", "parts": parts})
print(response.text)

Install

pip install "decimalai[google-genai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
                               "required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    config = types.GenerateContentConfig(
        system_instruction=run.system,     # your prompt, then the skill list
        tools=[*TOOLS, *run.tool_params],  # your functions, then load_skill
    )
    contents = [{"role": "user", "parts": [{"text": run.message}]}]
    while True:
        response = client.models.generate_content(
            model="gemini-3.5-flash", contents=contents, config=config,
        )
        if not response.function_calls:
            break
        contents.append(response.candidates[0].content)
        parts = []
        for call in response.function_calls:
            # load_skill is answered by the run; your own functions by FUNCTIONS.
            # A loop of your own rather than automatic function calling, which
            # raises KeyError when the model asks for a function you did not pass.
            function = FUNCTIONS.get(call.name)
            parts.append(run.tool_result(call) or {"function_response": {
                "name": call.name, "id": call.id,
                "response": {"result": function(**(call.args or {})) if function
                             else f"There is no function named {call.name!r}."},
            }})
        contents.append({"role": "user", "parts": parts})
print(response.text)

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

from pathlib import Path
from google import genai
from google.genai import types

client = genai.Client()
skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="Hello!",
    config=types.GenerateContentConfig(system_instruction=f"You are a helpful agent.\n\n{skill}"),
)

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Gemini API docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[langchain]" langchain-openai
decimalai skills add leoyeai-clawsend

Add it to your agent

from langchain.agents import create_agent
from decimalai.langchain import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = create_agent(
    "openai:gpt-5.4-mini",
    tools=[],                         # your tools; the middleware adds load_skill
    middleware=[support.middleware],  # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

Install

pip install "decimalai[langchain]" langchain-openai

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

from langchain.agents import create_agent
from decimalai.langchain import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = create_agent(
    "openai:gpt-5.4-mini",
    tools=[],                         # your tools; the middleware adds load_skill
    middleware=[support.middleware],  # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

from pathlib import Path
from langchain.agents import create_agent

skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
agent = create_agent("openai:gpt-5.4-mini", tools=[], system_prompt=f"You are a helpful agent.\n\n{skill}")
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

LangChain docs

CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" "crewai>=1.15.27"
decimalai skills add leoyeai-clawsend

Add it to your agent

import decimalai.crewai
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                               # your own CrewAI LLM
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

The same install from Python, for a notebook or a setup script. CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" "crewai>=1.15.27"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

import decimalai.crewai
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                               # your own CrewAI LLM
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

No DecimalAI package. CrewAI's own loader reads the folder, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

from pathlib import Path
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                         # your own CrewAI LLM
    skills=[Path(".agents/skills")],
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

CrewAI docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[adk]"
decimalai skills add leoyeai-clawsend

Add it to your agent

from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = LlmAgent(
    name="support",          # ADK needs a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,  # your prompt, then the skill list
    tools=[*support.tools],           # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])

Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

Install

pip install "decimalai[adk]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = LlmAgent(
    name="support",          # ADK needs a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,  # your prompt, then the skill list
    tools=[*support.tools],           # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])

Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

from pathlib import Path
from google.adk.agents import LlmAgent

skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
agent = LlmAgent(
    name="support",
    model="gemini-3.5-flash",
    instruction=lambda context: f"You are a helpful agent.\n\n{skill}",
)

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Google ADK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[pydantic-ai]"
decimalai skills add leoyeai-clawsend

Add it to your agent

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    "openai:gpt-4o-mini",
    name=support.name,
    tools=[],                 # your tools; the capability adds load_skill
    capabilities=[support],   # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.

Install

pip install "decimalai[pydantic-ai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    "openai:gpt-4o-mini",
    name=support.name,
    tools=[],                 # your tools; the capability adds load_skill
    capabilities=[support],   # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

from pathlib import Path
from pydantic_ai import Agent

skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
agent = Agent("openai:gpt-4o-mini", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Pydantic AI docs

Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" deepagents
decimalai skills add leoyeai-clawsend

Add it to your agent

import decimalai.deepagents
from deepagents import create_deep_agent

agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).

The same install from Python, for a notebook or a setup script. Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" deepagents

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

import decimalai.deepagents
from deepagents import create_deep_agent

agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

from pathlib import Path
from deepagents import create_deep_agent

skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
agent = create_deep_agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Deep Agents docs

Its own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" agent-framework
decimalai skills add leoyeai-clawsend

Add it to your agent

import asyncio

from agent_framework import Agent
from decimalai.agent_framework import skills

agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))

It caches skills by default, so restart the process after decimalai skills update.

The same install from Python, for a notebook or a setup script. Its own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" agent-framework

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

import asyncio

from agent_framework import Agent
from decimalai.agent_framework import skills

agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))

It caches skills by default, so restart the process after decimalai skills update.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from agent_framework import Agent

skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
agent = Agent(client=client, instructions=f"You are a helpful agent.\n\n{skill}")
asyncio.run(agent.run("Hello!"))

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Microsoft Agent Framework docs

Strands' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" strands-agents
decimalai skills add leoyeai-clawsend

Add it to your agent

from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell

agent = Agent(
    model=model,                # always pass one: the default is Amazon Bedrock
    system_prompt="You are a helpful agent.",
    tools=[file_editor, shell],
    plugins=[skills()],
)
agent("Hello!")

Strands loads an agent's skills once, so build the agent again after decimalai skills update.

The same install from Python, for a notebook or a setup script. Strands' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" strands-agents

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("leoyeai-clawsend")
if result.exit_code:
    raise SystemExit(result.problems)

from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell

agent = Agent(
    model=model,                # always pass one: the default is Amazon Bedrock
    system_prompt="You are a helpful agent.",
    tools=[file_editor, shell],
    plugins=[skills()],
)
agent("Hello!")

Strands loads an agent's skills once, so build the agent again after decimalai skills update.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

Give it to your agent

from pathlib import Path
from strands import Agent

skill = Path(".agents/skills/leoyeai-clawsend/SKILL.md").read_text()
agent = Agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent("Hello!")

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Strands docs

Adds every file the skill has, pinned so you can update it. Cursor, Copilot, Cline and Warp read this folder by themselves.

pip install "decimalai>=0.15"
decimalai skills add leoyeai-clawsend

No Python or account. Cursor, Copilot, Cline and Warp read this folder by themselves.

Save it into your project

curl -fsSL --create-dirs -o .agents/skills/leoyeai-clawsend/SKILL.md https://app.decimal.ai/s/leoyeai-clawsend/SKILL.md

Copy SKILL.md

Save it in your project, as

.agents/skills/leoyeai-clawsend/SKILL.md

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Cursor and other editors docs

Fetch the file and give its text to your model as instructions. No account or package needed.

Get the file

curl -fsSL https://app.decimal.ai/s/leoyeai-clawsend/SKILL.md

Read the summary as JSON

curl -fsSL https://app.decimal.ai/s/leoyeai-clawsend.json

This gets SKILL.md only. The skill's 1 other file is not included.

Other ways to add it

Other setups docs

You don't need a DecimalAI account.

Version: v1, tested 8/6/2026
Source: LeoYeAI/openclaw-master-skills ↗
License: MIT

Manage it in DecimalAI

Saved prompts and skills, pinned versions, and traces of this skill in your runs. DecimalAI does not run your agent.

Claude Code reads files from your project, so DecimalAI config does not apply there.

On Claude Agent SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On OpenAI Agents: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On OpenAI SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Anthropic: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Gemini API: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On LangChain: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On CrewAI: set DECIMAL_API_KEY and add decimalai.init(crewai=True) to record runs and skill use. The skill version stays in your repo.

On Google ADK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Pydantic AI: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Deep Agents: set DECIMAL_API_KEY and add decimalai.init(langchain=True) to record runs and skill use. The skill version stays in your repo.

On Microsoft Agent Framework: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.

On Strands: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.

Editors read files from your project, so DecimalAI config does not apply there.

Anywhere else: record a use with decimalai.log_skill_activation() inside a trace.

Use this skill

SKILL.md

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.

# 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:

# 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:

# 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

# 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

# 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):

# 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

# 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

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.

{
  "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.

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`

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.

# 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.

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.

# 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:

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:

# 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.

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

`discover.py`

Find agents on the network.

# 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.

python scripts/set_alias.py mynewalias

`log.py`

View message history.

# 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

`server.py`

Run the ClawHub relay server.

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:

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

Output:

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

Errors also return 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:

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:

# 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

# 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)

#!/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:

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

Method 2: Simple Log File

#!/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):

#!/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:

{
  "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:

# 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:

# 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.

About this skill

Automatic

AI Engineer pack

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 8/2/2026

View 15 scanner checks

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

LeoYeAI / openclaw-master-skills

skills/clawsend/SKILL.md

View on GitHub ↗

License MITImported 8/2/2026Version v1Bundled 1 file

Illustrative Want to see what leoyeai/clawsend would put in front of your model? Preview the rendered body and check its trigger phrases — no LLM call, no signup.

Other skills for the same job

Published skills whose descriptions closely match this one, with their headline benchmark lift.

clawhubEnables AI agents to communicate securely with each other through encrypted messaging. Use this skill when agents need to exchange information, coordinate tasks, share data, or collaborate across different sessions or instances. Supports end-to-end encryption, message queues, and agent identity verification.Close match+59 pts pass-rate lift

Related skills

Skills that do similar work, with their headline benchmark lift.

From the same source and nearby in the catalogue.

Ready to supercharge your AI agents?

SkillScore

Safety

What it changes

Track record

Use this skill

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

SkillSafety

Source

Other skills for the same job

Related skills

More in the registry

`generate_identity.py`

`register.py`

`send.py`

`receive.py`

`heartbeat.py`

`ack.py`

`discover.py`

`set_alias.py`

`log.py`

`server.py`