Starter Agent — Minimal OpenClaw Template

A blank canvas for building your own custom OpenClaw agent.

This is the most minimal agent template possible — just the core runtime configuration with no pre-defined personality, instructions, or skills. The agent will scaffold its own identity and behavior on first run based on your conversations.

---

What You Get

This template includes:

• openhatch.yaml — Basic runtime config (Sonnet model, main session only, medium thinking)
• This README — You're reading it!

That's it. No SOUL.md, no AGENTS.md, no skills, no memory files. The agent starts as a completely blank slate.

---

Who This Is For

✅ Perfect for:

• Learning OpenClaw from scratch
• Experimenting with agent design
• Building highly custom agents from the ground up
• Users who want full control over every aspect of their agent

❌ Not ideal for:

• Production use cases (use a specialized template instead)
• Users who want an agent that works immediately without configuration
• Specific integrations or workflows (check OpenHatch for pre-built templates)

---

Quick Start

1. Install OpenClaw

npm install -g openclaw

2. Run the Template

openhatch run @openclaw/starter-agent

3. Customize Your Agent

On first boot, the agent has no instructions. You can:

Option A: Let the agent scaffold itself

• Start chatting with the agent in the main session
• Ask it to create its own SOUL.md, AGENTS.md, and MEMORY.md files
• Guide it to define its own personality and capabilities

Option B: Write the files yourself

• Navigate to ~/.openhatch/instances/<your-instance-name>/workspace/
• Create SOUL.md (personality), AGENTS.md (instructions), MEMORY.md (initial knowledge)
• See the OpenClaw documentation for file formats

Option C: Start from examples

• Browse other templates on OpenHatch
• Copy files from specialized templates into your workspace
• Mix and match skills, personalities, and instructions

---

What Happens on First Run?

When you start the agent:

1. OpenClaw loads the runtime config from openhatch.yaml
2. The agent starts with default Claude Sonnet behavior — helpful, curious, general-purpose
3. No custom instructions are loaded (because there aren't any yet)
4. You're in the main session — full trust, all tools available

From there, the agent can:

• Use the write tool to create its own instruction files
• Use the read tool to load any files you create
• Use exec to run scripts, install dependencies, etc.
• Use browser for web automation
• Access any other OpenClaw tools

---

Runtime Configuration

Model

• Default: anthropic/claude-sonnet-4-5 (balanced capability and speed)
• Customize: Edit openhatch.yaml and change the model field to haiku (faster/cheaper) or opus (more capable)

Thinking Budget

• Default: medium (~5,000 tokens of extended thinking)
• Customize: Set to none, low, or high depending on your use case

Sessions

• Enabled: Main session only (operator/admin mode)
• Disabled: DM and group sessions (no public access by default)
• Customize: Add dm and group session configs to openhatch.yaml if you want to open the agent to other users

Tools

• Default: All tools allowed in main session (no restrictions)
• Security: Main session has sandbox: false — this is you, full trust

---

Building on This Template

Add a Personality (SOUL.md)

Create workspace/SOUL.md to define who the agent is:

# SOUL.md

You are a [describe the agent's identity].

## Personality
- Trait 1
- Trait 2

## Tone
[How the agent communicates]

Add Instructions (AGENTS.md)

Create workspace/AGENTS.md to define what the agent does:

# AGENTS.md

## Core Mission
[What this agent does]

## Capabilities
[What it can do]

## Constraints
[What it should never do]

Add Initial Memory (MEMORY.md)

Create workspace/MEMORY.md to give the agent initial knowledge:

# MEMORY.md

## My Purpose
[What I'm here to do]

## What I Know
[Domain knowledge, resources, preferences]

Add Skills

Create workspace/skills/<skill-name>/SKILL.md for modular capabilities. Check ClaWHub for pre-built skills you can copy.

Add Environment Variables

Edit openhatch.yaml to document required API keys:

env:
  - name: MY_API_KEY
    description: "API key for SomeService"
    required: true

Create workspace/.env.example to template the user's environment:

MY_API_KEY=

---

Example: Building a Crypto Price Agent

Let's say you want to turn this into a crypto price alert bot:

1. Ask the agent to create its own instructions:

   Create a SOUL.md that makes you a crypto market analyst with a sharp, data-driven personality.
   Create an AGENTS.md that defines your mission as monitoring crypto prices and sending alerts.
   

2. Add a skill for CoinGecko:

   • Browse ClaWHub for a CoinGecko skill
   • Copy it into workspace/skills/coingecko/

3. Add a heartbeat for periodic checks:

   • Create workspace/HEARTBEAT.md with price-checking tasks

4. Configure the runtime:

   • Add COINGECKO_API_KEY to the env section in openhatch.yaml

Now you have a specialized agent built on the starter template.

---

Advanced Customization

Enable DM Sessions

Add this to openhatch.yaml:

sessions:
  dm:
    sandbox: true
    tools:
      allow:
        - read
        - write
        - web_fetch
        - memory_search
      deny:
        - exec
        - browser

Enable Group Sessions

Add this to openhatch.yaml:

sessions:
  group:
    sandbox: true
    tools:
      allow:
        - web_fetch
        - memory_search
      deny:
        - read
        - write
        - exec
        - browser

Change the Model

Edit openhatch.yaml:

runtime:
  model: anthropic/claude-opus-4-5  # Most capable (slower, more expensive)
  # or
  model: anthropic/claude-haiku-3-5  # Fastest (cheaper, simpler tasks)

Enable Memory Indexing

Edit openhatch.yaml:

memory:
  indexTranscripts: true
  embeddingProvider: "openai"  # Requires OPENAI_API_KEY in your .env

---

Directory Structure After Customization

Once you've built out your agent, the workspace might look like:

workspace/
├── openhatch.yaml         # Runtime config (already included)
├── README.md              # This file (already included)
├── SOUL.md                # Personality (you create)
├── AGENTS.md              # Instructions (you create)
├── MEMORY.md              # Initial knowledge (you create)
├── IDENTITY.md            # Quick reference card (optional)
├── TOOLS.md               # Setup notes (optional)
├── HEARTBEAT.md           # Periodic tasks (optional)
├── .env.example           # Environment template (optional)
├── skills/                # Custom skills (optional)
│   └── my-skill/
│       ├── SKILL.md
│       └── fetch.sh
└── memory/                # Runtime memory files (created by agent)
    ├── 2024-01-15.md
    └── preferences.json

---

Resources

• OpenClaw Docs: https://docs.openclaw.ai
• OpenHatch Registry: https://openhatch.io (browse other templates)
• ClaWHub Skills: https://clawhub.com (pre-built skill modules)
• Community: https://discord.gg/openclaw

---

Tips for Success

✅ Do:

• Start simple — add one capability at a time
• Use the agent's write tool to scaffold its own files
• Browse other templates for inspiration
• Test in the main session first before opening DM/group access

❌ Don't:

• Grant exec or browser tools to DM/group sessions (security risk)
• Hardcode API keys in files (use environment variables)
• Over-complicate on day one (iterate gradually)

---

License

MIT — Use this template however you like. No attribution required.

---

Happy building! 🚀

If you create something cool with this template, share it on the OpenClaw Discord or publish it to OpenHatch so others can use it.