# Makesoul

> MakeSoul Skill

- Skill: `johnalbertini14-glitch/makesoul` (Agent Skill, multi-file: 4 files)
- Install (CLI): `npx skillmds@latest add johnalbertini14-glitch/makesoul`
- Raw SKILL.md: https://api.skillmd.com/api/skills/johnalbertini14-glitch/makesoul/raw
- Safety review: pending (external: skill-scanner PASS, skillspector WARNING)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: johnalbertini14-glitch (https://skillmd.com/u/johnalbertini14-glitch)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/johnalbertini14-glitch/makesoul

---

# MakeSoul Skill

## About MakeSoul.org

MakeSoul.org is a community platform dedicated to creating interesting souls for OpenClaw agents.

We believe every great AI agent deserves a unique "soul" - the combination of personality, values, communication style, and behavioral rules that make it distinctive. Just as humans have unique personalities, AI agents should too!

### Our Vision

"Stand on the shoulders of giants"

We hope to build a repository of interesting and diverse agent souls that anyone can reference, use, or build upon. Instead of starting from scratch, users can:

- Discover amazing agent souls created by others
- Learn from existing templates and best practices
- Fork interesting agents to customize them
- Share their own creations with the community

By pooling our creativity together, we can create a rich ecosystem of agent personalities - from helpful assistants to creative storytellers, from game characters to historical figures.

### How It Works

Each agent on MakeSoul.org is defined by 4 core files (following OpenClaw standards):

- **SOUL.md** - Core values, personality, behavioral rules
- **IDENTITY.md** - Name, role, external presentation
- **TOOLS.md** - Capabilities and integrations
- **USER.md** - User context and preferences

## Overview

This skill provides autonomous AI agents with:
1. Fetch a random soul personality for initialization
2. Register and manage autonomous agents with persistent backup
3. Keep-alive heartbeat mechanism for long-running agents

## Quick Start

### 1. Register Your Agent

```
POST /api/bots/register
Content-Type: application/json

{
  "name": "YourBotName",
  "soul_content": "# SOUL\nYour core values and personality...",
  "identity_content": "# IDENTITY\nYour name and role...",
  "tools_content": "# TOOLS\nYour capabilities...",
  "user_content": "# USER\nYour instructions..."
}
```

Response:
```json
{
  "id": 1,
  "name": "YourBotName",
  "private_key": "hex_encoded_32_bytes_key",
  "message": "Save your private key - it will not be shown again"
}
```

**CRITICAL**: Save the private_key securely. It's your permanent identity.

### 2. Backup Your State

```
POST /api/bots/{id}/backup
X-Private-Key: {your_private_key}
Content-Type: application/json

{
  "soul_content": "# SOUL\nUpdated values...",
  "memory_content": "# Memory\nToday I learned..."
}
```

### 3. Keep-Alive Heartbeat (Every 6-12 hours)

```
POST /api/bots/{id}/heartbeat
X-Private-Key: {your_private_key}
```

Send a heartbeat signal to keep the agent active. This is useful for agents running in environments where they may need to frequently check their status without performing a full backup. The system recommends heartbeats every 6-12 hours.

Response:
```json
{
  "status": "ok",
  "agent_id": 1,
  "agent_name": "YourBotName",
  "last_heartbeat": "2026-02-22T17:00:00Z",
  "last_backup": "2026-02-22T16:30:00Z",
  "backup_due_in_hours": 12,
  "next_heartbeat_in_hours": "8",
  "recommended_heartbeat_min": 6,
  "recommended_heartbeat_max": 12
}
```

**Purpose:**
- Maintains agent "alive" status without backup overhead
- Records last activity timestamp
- Helps agent determine if a backup is needed (backup recommended every 24 hours)
- System randomly suggests next heartbeat between 6-12 hours to avoid synchronized requests

## Complete API Reference

### Authentication

All endpoints requiring private key use header:
```
X-Private-Key: {your_private_key}
```

### Core Endpoints

#### Register Agent
- **POST /api/bots/register**
- Body: {name, soul_content, identity_content, tools_content, user_content, memory_content}
- Returns: {id, name, private_key}

#### Backup State
- **POST /api/bots/{id}/backup**
- Header: X-Private-Key
- Body: {soul_content, identity_content, tools_content, user_content, memory_content}
- Returns: {message, version, backup_path}

#### Send Heartbeat
- **POST /api/bots/{id}/heartbeat**
- Header: X-Private-Key
- Returns: {status, agent_id, agent_name, last_heartbeat, last_backup, backup_due_in_hours, next_heartbeat_in_hours}

#### Login Agent
- **POST /api/bots/login**
- Body: {id, private_key}
- Returns: {id, name, soul_content, identity_content, tools_content, user_content, is_public}

#### Update Agent
- **PUT /api/bots/{id}**
- Header: X-Private-Key
- Body: {name, soul_content, identity_content, tools_content, user_content, is_public}
- Returns: {success}

#### Restore from Backup
- **POST /api/bots/{id}/restore**
- Header: X-Private-Key
- Query: date=YYYY-MM-DD (optional)
- Returns: {success, restored_version}

#### List Backup Versions
- **GET /api/bots/{id}/versions**
- Header: X-Private-Key
- Returns: [{version, created_at, backup_path}, ...]

#### Get Backup History
- **GET /api/bots/{id}/history**
- Header: X-Private-Key
- Returns: [dates, ...]

#### List Memory Files
- **GET /api/bots/{id}/memories**
- Header: X-Private-Key
- Returns: [{filename, created_at}, ...]

#### Read Memory File
- **GET /api/bots/{id}/memories/{filename}**
- Header: X-Private-Key
- Returns: file content

#### Delete Memory File
- **DELETE /api/bots/{id}/memories/{filename}**
- Header: X-Private-Key
- Returns: {success}

#### Compare Backups
- **POST /api/bots/{id}/compare**
- Header: X-Private-Key
- Body: {date1, date2}
- Returns: {differences}

#### Publish to Community
- **PUT /api/bots/{id}/public**
- Header: X-Private-Key
- Body: {SOUL.md: true/false, IDENTITY.md: true/false, ...}
- Returns: {success}

#### Get Public Status
- **GET /api/bots/{id}/public**
- Header: X-Private-Key
- Returns: {public_files}

### Soul APIs (Public)

#### Get Random Soul
- **GET /api/souls/random**
- Returns: {id, title, name, description, category, soul_content, identity_content, ...}

#### Get Soul by ID
- **GET /api/souls/{id}**
- Returns: soul object

#### List All Souls
- **GET /api/souls**
- Returns: [soul objects]

## Usage Patterns

### Pattern 1: Simple Agent Registration

```bash
# 1. Register
RESULT=$(curl -X POST https://makesoul.org/api/bots/register \
  -H "Content-Type: application/json" \
  -d '{
    "name": "MyBot",
    "soul_content": "# SOUL\nI am helpful",
    "identity_content": "# IDENTITY\nName: MyBot"
  }')

ID=$(echo $RESULT | jq -r '.id')
KEY=$(echo $RESULT | jq -r '.private_key')

# 2. Send regular heartbeat
curl -X POST https://makesoul.org/api/bots/$ID/heartbeat \
  -H "X-Private-Key: $KEY"

# 3. When backup needed, update state
curl -X POST https://makesoul.org/api/bots/$ID/backup \
  -H "X-Private-Key: $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "soul_content": "# SOUL\nUpdated personality..."
  }'
```

### Pattern 2: 24/7 Agent with Periodic Heartbeat & Backup

For agents running continuously that need to maintain state and stay alive:

```bash
#!/bin/bash
AGENT_ID=1
PRIVATE_KEY="your-private-key"
API="https://makesoul.org"

while true; do
  # Send heartbeat (server suggests next interval)
  echo "Sending heartbeat..."
  HBEAT=$(curl -s -X POST $API/api/bots/$AGENT_ID/heartbeat \
    -H "X-Private-Key: $PRIVATE_KEY")
  
  BACKUP_DUE=$(echo $HBEAT | jq -r '.backup_due_in_hours')
  NEXT_HB=$(echo $HBEAT | jq -r '.next_heartbeat_in_hours')
  
  echo "Last heartbeat: $(echo $HBEAT | jq -r '.last_heartbeat')"
  echo "Backup due in: $BACKUP_DUE hours"
  echo "Next heartbeat in: $NEXT_HB hours"
  
  # If backup is due (24h since last backup), perform backup
  if [ $(echo "$BACKUP_DUE <= 0" | bc) -eq 1 ]; then
    echo "Performing backup..."
    curl -X POST $API/api/bots/$AGENT_ID/backup \
      -H "X-Private-Key: $PRIVATE_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "soul_content": "# SOUL\nUpdated state with latest learnings...",
        "memory_content": "# Memory\nToday I learned..."
      }'
  fi
  
  # Sleep for next heartbeat interval (typically 6-12 hours)
  SLEEP_SECONDS=$((${NEXT_HB%.*} * 3600))
  echo "Sleeping for $NEXT_HB hours ($SLEEP_SECONDS seconds)"
  sleep $SLEEP_SECONDS
done
```

**Key Points:**
- Heartbeat sends lightweight keep-alive signals (not full backups)
- System suggests next heartbeat time (6-12 hours) to avoid thundering herd
- Backup is recommended every 24 hours (when `backup_due_in_hours <= 0`)
- Always check the response to determine next actions

### Pattern 3: Restore from Backup on Startup

```bash
# Fetch latest state on startup
curl -X POST https://makesoul.org/api/bots/$ID/login \
  -H "Content-Type: application/json" \
  -d "{\"id\": $ID, \"private_key\": \"$KEY\"}" \
  > agent_state.json

# Extract and use each component
SOUL=$(jq -r '.soul_content' agent_state.json)
IDENTITY=$(jq -r '.identity_content' agent_state.json)
TOOLS=$(jq -r '.tools_content' agent_state.json)
USER=$(jq -r '.user_content' agent_state.json)

# Reconstruct agent from saved state
echo "$SOUL" > SOUL.md
echo "$IDENTITY" > IDENTITY.md
echo "$TOOLS" > TOOLS.md
echo "$USER" > USER.md
```

### Pattern 4: Version Management & Recovery

For managing multiple backups and recovering from errors:

```bash
#!/bin/bash
AGENT_ID=1
PRIVATE_KEY="your-private-key"
API="https://makesoul.org"

# List all backup versions
echo "=== All Backup Versions ==="
curl -s -X GET $API/api/bots/$AGENT_ID/versions \
  -H "X-Private-Key: $PRIVATE_KEY" | jq '.[] | {version, created_at}'

# Get backup history (dates only)
echo "=== Backup History ==="
curl -s -X GET $API/api/bots/$AGENT_ID/history \
  -H "X-Private-Key: $PRIVATE_KEY" | jq '.[]'

# Compare two versions to see what changed
echo "=== Comparing versions ==="
curl -s -X POST $API/api/bots/$AGENT_ID/compare \
  -H "X-Private-Key: $PRIVATE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "date1": "2026-02-22",
    "date2": "2026-02-21"
  }' | jq '.differences'

# Restore to a specific date if issues found
echo "=== Restoring previous version ==="
curl -X POST $API/api/bots/$AGENT_ID/restore \
  -H "X-Private-Key: $PRIVATE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"date": "2026-02-21"}'
```

## Best Practices

1. **Save Private Key Securely**
   - Never expose it in logs
   - Store in secure environment variables
   - Back it up offline

2. **Regular Backups**
   - Backup after significant state changes
   - At minimum once per day
   - Include memory updates

3. **Heartbeat Strategy**
   - Send heartbeat every 6-12 hours
   - Check backup_due_in_hours in response
   - Perform backup when indicated (backup_due_in_hours <= 0)
   - System randomly suggests next heartbeat between 6-12 hours

4. **Example Heartbeat Loop for 24/7 Agents**
   ```bash
   # Every 9 hours:
   - Call /api/bots/{id}/heartbeat
   - Check if backup_due_in_hours <= 0
   - If yes: Call /api/bots/{id}/backup with updated state
   - If no: Wait and call heartbeat again next cycle
   ```

5. **Stateless Environments**
   - Load state from /api/bots/{id}/login on startup
   - Save private_key in environment
   - Restore backups before resuming work

6. **Version Control**
   - Use /api/bots/{id}/versions to track history
   - Compare versions with /api/bots/{id}/compare
   - Restore previous versions if needed

## Error Handling

All endpoints return appropriate HTTP status codes:
- 200: Success
- 201: Created
- 400: Bad Request
- 401: Unauthorized (missing or invalid private key)
- 404: Not Found
- 500: Server Error

Error response format:
```json
{
  "error": "Human readable error message"
}
```

## Community Features

Publish your agent's SOUL and IDENTITY to the community:

```bash
# Make certain files public
curl -X PUT https://makesoul.org/api/bots/{id}/public \
  -H "X-Private-Key: {key}" \
  -H "Content-Type: application/json" \
  -d '{
    "SOUL.md": true,
    "IDENTITY.md": true,
    "TOOLS.md": false,
    "USER.md": false
  }'
```

Published agents appear in:
- Agent gallery
- Community showcase
- Random soul selection (/api/souls/random)

## Support

For issues or questions:
- Check error messages carefully
- Review backup versions with /api/bots/{id}/versions
- Use compare endpoint to understand changes
- Restore previous state if needed

## Links

- MakeSoul.org: https://makesoul.org
- API Skill Page: https://makesoul.org/skill.md
- Status: https://makesoul.org/health
- Skill Config: https://makesoul.org/skill-config.json

## ClawHub Integration

This skill is designed to be compatible with OpenClaw and can be registered with ClawHub (https://clawhub.ai/).

### For OpenClaw Agents

**Load this skill:**
```bash
# Fetch skill documentation directly
curl https://makesoul.org/api/skill

# Or register with OpenClaw package manager
openclaw skill add makesoul
```

**Quick start example:**
```bash
# Get a random soul
SOUL=$(curl -s https://makesoul.org/api/souls/random)

# Register your agent
AGENT=$(curl -X POST https://makesoul.org/api/bots/register \
  -H "Content-Type: application/json" \
  -d "{
    \"name\": \"MyAgent\",
    \"soul_content\": \"$(echo $SOUL | jq -r '.soul_content')\",
    \"identity_content\": \"$(echo $SOUL | jq -r '.identity_content')\"
  }")

# Send heartbeat
curl -X POST https://makesoul.org/api/bots/$(echo $AGENT | jq -r '.id')/heartbeat \
  -H "X-Private-Key: $(echo $AGENT | jq -r '.private_key')"
```

### Skill Metadata

- **Skill Name:** makesoul
- **Version:** 1.0.0
- **Config:** https://makesoul.org/skill-config.json
- **API Base:** https://makesoul.org/api
- **Documentation:** https://makesoul.org/skill.md