Agent Maker

---

name: agent-maker

description: Create autonomous AI agents for OpenClaw with guided discovery — clarifies purpose, personality, skills, channels, automation, and security before generating a fully configured agent workspace.

---

# Agent Maker

Create autonomous AI agents for OpenClaw through an intelligent guided process.

How This Skill Works

When the user wants to create a new agent, you MUST follow the **Discovery Flow** below to gather requirements before running any creation scripts. Do NOT immediately ask for all parameters at once — guide the user through a natural conversation to understand what they truly need.

Discovery Flow

Phase 1: Purpose & Identity

Start by understanding the agent's core purpose. Ask ONE question at a time and build on answers:

**1. What problem does this agent solve?**

**2. Derive identity from purpose:**

**3. Choose the right model based on workload:**

| Use Case | Recommended Model | Why |

|----------|------------------|-----|

| Deep research, complex reasoning, coding | `anthropic/claude-opus-4-6` | Most capable, best for complex tasks |

| General tasks, balanced cost/quality | `anthropic/claude-sonnet-4-6` | Good balance of speed and capability |

| Fast responses, simple tasks, high volume | `anthropic/claude-haiku-4-5` | Fastest and cheapest |

| Image generation/understanding | `google/gemini-2.5-flash` | Strong multimodal capabilities |

| Budget-friendly, coding-focused | `deepseek/deepseek-chat` | Cost-effective for code tasks |

Ask the user about their priorities (quality vs cost vs speed) to recommend the right model.

Phase 2: Personality & Behavior

**4. Define personality traits:**

**5. Define boundaries:**

Phase 3: Workflow & Tools

**6. What is the agent's main workflow?**

Walk through a typical interaction:

**7. What tools does this agent need?**

Available built-in tools:

Should any tools be **denied** for security? (e.g., deny `exec`, `write` for a read-only agent)

**8. Does this agent need specific skills?**

Phase 4: Communication & Channels

**9. How will users interact with this agent?**

Options:

**10. Multi-agent coordination:**

If channels are needed, you'll need to set up **bindings** to route messages to this agent. Example:

{
  bindings: [
    { agentId: "agent-id", match: { channel: "telegram", accountId: "agent-bot" } }
  ]
}

Phase 5: Automation & Memory

**11. Does this agent need scheduled tasks?**

Two options — explain the difference:

| Feature | Heartbeat | Cron |

|---------|-----------|------|

| Runs in | Main session (shared context) | Isolated or main session |

| Timing | Periodic interval (e.g., every 30m) | Exact schedule (cron expression) |

| Best for | Monitoring, checking inbox, context-aware tasks | Reports, reminders, exact-time tasks |

| Cost | Lower (batched checks) | Per-job cost |

**Heartbeat setup** (recommended for monitoring agents):

**Cron setup** (recommended for scheduled tasks):

**12. Memory configuration:**

Phase 6: Security & Sandbox

**13. Security posture:**

| Mode | Description | Use Case |

|------|-------------|----------|

| `off` | No sandboxing, full host access | Trusted personal agents |

| `non-main` | Sandbox non-main sessions only | Mixed trust environments |

| `all` | Full sandbox for all sessions | Untrusted inputs, shared agents |

Agent Creation

After gathering all requirements, create the agent using this process:

Step 1: Create agent via CLI

openclaw agents add <agent-id>

This creates the proper directory structure under `~/.openclaw/agents/<agent-id>/`.

Step 2: Create workspace & files

Run the creation script with gathered parameters:

{baseDir}/scripts/create-agent.sh \
  --name "Agent Name" \
  --id "agent-id" \
  --emoji "🤖" \
  --specialty "What this agent does" \
  --model "provider/model-name" \
  --workspace "/path/to/workspace" \
  --personality "Communication style and traits" \
  --boundaries "What the agent should not do" \
  --workflow "Step-by-step workflow description" \
  --tools-allow "tool1,tool2,tool3" \
  --tools-deny "tool4,tool5" \
  --autonomy "tier1|tier2|tier3" \
  --heartbeat-every "30m" \
  --heartbeat-target "last" \
  --heartbeat-active-hours "08:00-22:00" \
  --sandbox "off|non-main|all"

The script creates these workspace files:

Step 3: Update gateway config

The script automatically:

Step 4: Configure bindings (if channels needed)

If the agent needs channel routing, apply a config patch:

openclaw gateway config.patch --raw '{
  "bindings": [
    {
      "agentId": "<agent-id>",
      "match": { "channel": "<channel>", "accountId": "<account>" }
    }
  ]
}'

Step 5: Set up cron jobs (if needed)

openclaw cron add \
  --name "<Job Name>" \
  --cron "<cron expression>" \
  --tz "<timezone>" \
  --session "<agent-id>" \
  --system-event "<instruction>" \
  --wake now

Step 6: Set up skills (if needed)

For agent-specific skills, create them in `<workspace>/skills/`:

mkdir -p <workspace>/skills/<skill-name>
# Create SKILL.md in the skill directory

For shared skills:

openclaw skills install <skill-slug>

Step 7: Verify & test

# Verify agent is registered
openclaw agents list --bindings

# Check gateway status
openclaw gateway status

# Test the agent
openclaw agent --agent <agent-id> --message "Hello! Introduce yourself."

# Or via session tools
sessions_send({ label: "<agent-id>", message: "Hello!" })

Post-Creation Customization

After the agent is created, help the user refine:

1. **SOUL.md** — Review and refine personality, add specific instructions

2. **AGENTS.md** — Add standing orders, red lines, specific rules

3. **HEARTBEAT.md** — Fine-tune periodic checklist

4. **TOOLS.md** — Document tool-specific conventions

5. **Workspace skills** — Create agent-specific skills if needed

Example Discovery Conversations

Example 1: Research Agent

**User:** "I want an agent that does deep research for me"

**Discovery:**

Example 2: Family Group Bot

**User:** "I need a bot for my family WhatsApp group"

**Discovery:**

Example 3: Health Tracker

**User:** "I want an agent to track my health and remind me of medications"

**Discovery:**

Inter-Agent Coordination

After creating an agent, explain how it fits into the user's multi-agent system:

List agents

sessions_list({ kinds: ["agent"], limit: 10, messageLimit: 3 })

Send tasks to agents

sessions_send({
  label: "agent-id",
  message: "Your task description here"
})

Spawn isolated sub-agent work

sessions_spawn({
  agentId: "agent-id",
  task: "Complex task description",
  model: "anthropic/claude-opus-4-6",
  runTimeoutSeconds: 3600,
  cleanup: "delete"
})

Check agent history

sessions_history({ sessionKey: "agent-session-key", limit: 50 })

Troubleshooting

**"Agent not appearing after creation"**

**"Agent not responding to messages"**

**"Model errors"**

**"Heartbeat not running"**

**"Cron job not firing"**

Requirements