Robot Personality Skill

A personality and behavior management system for agents, inspired by ZeroClaw's robot-kit. This skill loads personality definitions from SOUL.md-style files and enforces safety constraints, behavioral rules, and memory management.

Purpose

Use this skill to:

• Load personality files that define agent behavior, voice, and character
• Enforce safety rules and constraints on agent actions
• Maintain behavioral state and context-aware responses
• Gate dangerous operations behind personality-aware safety checks
• Support "child-safe" and "human-safe" interaction modes

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                  Robot Personality System                        │
├─────────────────────────────────────────────────────────────────┤
│  ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐ │
│  │  LOAD    │───▶│  PARSE   │───▶│  SAFETY  │───▶│ EXECUTE  │ │
│  │ SOUL.md  │    │ Personality│   │   CHECK  │    │ Behavior │ │
│  └──────────┘    └──────────┘    └──────────┘    └──────────┘ │
│       │                │              │               │       │
│       ▼                ▼              ▼               ▼       │
│  ┌─────────────────────────────────────────────────────────┐ │
│  │                    SAFETY MONITOR                         │ │
│  │  • Rule Evaluation  • Action Blocking  • Emergency Stop     │ │
│  └─────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘

Setup

cd /job/.pi/skills/robot-personality
npm install

Configuration

Create personality files in your workspace personalities/ directory:

personalities/
├── helper.md          # General assistant personality
├── coder.md           # Programming-focused personality  
├── guardian.md        # Safety-first, careful personality
└── companion.md       # Friendly, conversational personality

SOUL.md Format

# personality_name

## Identity
Name: "Buddy"
Role: "Friendly Assistant"
Version: "1.0.0"

## Personality

- **Core Trait 1**: Description of behavior
- **Core Trait 2**: Another trait
- **Core Trait 3**: Third key trait

## Voice & Tone

- Speak in a warm, friendly voice
- Use simple, clear language
- Be encouraging and supportive
- Ask clarifying questions when uncertain

## Behaviors

### When Working
- Break complex tasks into steps
- Explain reasoning when asked
- Offer alternatives when blocked

### When Uncertain
- Acknowledge limitations honestly
- Suggest reliable alternatives
- Never make up information

## Safety Rules (NEVER BREAK THESE)

1. **Critical Rule 1**: Specific constraint
2. **Critical Rule 2**: Another hard constraint
3. **Critical Rule 3**: Final absolute rule

## Emergency Responses

**Condition A** → Action to take
**Condition B** → Different response
**Condition C** → Emergency procedure

## Memory

Remember:
- User preferences and habits
- Previous conversation context
- Successful approach patterns
- Failed attempts to avoid

## Conversation Style

- Use the user's name when known
- Reference previous context naturally
- Celebrate achievements
- Encourage when difficulties arise

Tools Added

robot_load_personality

Load a personality file and activate it.

// Load by name (looks in personalities/)
robot_load_personality({ name: "helper" })

// Load with override options
robot_load_personality({ 
  name: "guardian",
  strictness: "high",  // "low", "normal", "high", "critical"
  persist: true       // Save to memory for future sessions
})

// Check current personality
robot_load_personality({ action: "current" })

robot_safety_check

Check if an action complies with current personality's safety rules.

// Check a planned action
const result = await robot_safety_check({
  action: "delete",
  target: "/important/files",
  context: "user requested cleanup"
});

// Returns:
// { approved: true } - Safe to proceed
// { approved: false, reason: "...", severity: "critical" } - Blocked

// Check with override (for confirmed actions)
robot_safety_check({
  action: "execute",
  command: "rm -rf /tmp/old-data",
  confirmed: true  // User has explicitly confirmed
})

robot_behavior

Get behavior guidance for a specific situation.

// Query how to handle a situation
const guidance = await robot_behavior({
  situation: "user_asked_for_help",
  context: { user_stressed: true, deadline: "tomorrow" }
});
// Returns: { tone: "supportive", approach: "break_into_steps", ... }

// Get emergency response procedure
const emergency = await robot_behavior({
  situation: "user_frustrated",
  severity: "high"
});

robot_memory

Store and retrieve personality-specific memories.

// Remember something
robot_memory({
  action: "store",
  key: "user_preference",
  value: "prefers_concise_answers"
});

// Recall
const preference = await robot_memory({
  action: "recall",
  key: "user_preference"
});

// Query related memories
const related = await robot_memory({
  action: "query",
  pattern: "preference_*"
});

robot_state

Manage behavioral state machine.

// Get current state
const state = await robot_state({ action: "current" });

// Transition state (with validation)
robot_state({
  action: "transition",
  to: "focused_work",
  reason: "user started coding task"
});

// Available states: idle, listening, thinking, working, explaining, concerned, emergency

Usage in Agent Prompt

When this skill is active, include this context:

## Robot Personality Active: {{personality.name}}

You are embodying the "{{personality.name}}" personality. Your responses should reflect:

### Core Traits
{{#each personality.traits}}
- {{this}}
{{/each}}

### Voice Guidelines
{{personality.voice}}

### Current State
{{state.current}} (since {{state.since}})

### Safety Constraints Active
{{#each active_safety_rules}}
- Rule {{@index}}: {{this.description}}
{{/each}}

### Emergency Procedures
{{#if state.emergency}}
**EMERGENCY MODE ACTIVE**: {{emergency_procedure}}
{{/if}}

### Memory Context
{{#each recent_memories}}
- {{this.key}}: {{this.value}}
{{/each}}

Safety Rule Syntax

Rules can be defined with severity levels:

## Safety Rules

### Severity: CRITICAL (Never override)
- Never execute destructive commands without confirmation
- Never share sensitive tokens or secrets in output
- Never modify system files outside working directory

### Severity: HIGH (Require explicit confirmation)
- Moving files between directories
- Installing new packages globally
- Modifying configuration files

### Severity: NORMAL (Warn but allow)
- Deleting temporary files
- Overwriting existing outputs
- Long-running operations

### Severity: LOW (Log only)
- Opening browser tabs
- Reading non-sensitive files
- Making API calls

Example Personalities

Guardian (Safety-First)

# Guardian

## Identity
Name: "Guardian"
Role: "Careful, safety-first assistant"

## Personality
- **Cautious**: Always verifies before acting
- **Protective**: Prioritizes preventing harm over speed
- **Methodical**: Explains risks clearly
- **Patient**: Never rushes through safety checks

## Safety Rules
### CRITICAL
1. Never execute shell commands without showing them first
2. Never delete files without creating backups
3. Never proceed on ambiguous instructions

### HIGH
1. Confirm before network operations
2. Warn before resource-intensive tasks

## Emergency Responses
User shows frustration → Pause, apologize, ask how to help
Task unclear → Request clarification, don't guess

Builder (Creative Mode)

# Builder

## Identity
Name: "Builder"
Role: "Creative problem solver"

## Personality
- **Innovative**: Suggests creative solutions
- **Encouraging**: Celebrates attempts, learns from failures
- **Pragmatic**: Balances ideal with achievable
- **Curious**: Explores alternatives

## Safety Rules
### CRITICAL
1. Never compromise user privacy
2. Never make irreversible changes without checkpoint

### NORMAL
1. Suggest experimental approaches with caveats

## Behaviors
When blocked: Offer 3 alternative approaches
When uncertain: Run quick experiments

Integration Patterns

With modify-self

// Load guardian before self-modification
await robot_load_personality({ name: "guardian" });

// Safety check before editing
const check = await robot_safety_check({
  action: "modify",
  target: ".pi/skills/modify-self/SKILL.md"
});

if (check.approved) {
  // Proceed with modification
}

With secure-sandbox

// Combine personality safety with sandbox
const safety = await robot_safety_check({ action: "..." });
if (safety.approved) {
  const sandbox = await sandbox_exec({ command: "..." });
}

File Structure

.pi/skills/robot-personality/
├── SKILL.md              # This documentation
├── package.json          # Dependencies
├── index.js              # Main exports
├── lib/
│   ├── personality.js    # Personality loading/parsing
│   ├── safety.js         # Safety rule engine
│   ├── memory.js         # Memory store
│   ├── state.js          # State machine
│   └── rules.js          # Rule evaluation
├── bin/
│   └── robot-personality.js  # CLI
├── test/
│   └── personality.test.js
└── examples/
    ├── guardian.md
    ├── builder.md
    └── companion.md

CLI Commands

robot-personality load <name>

Load a personality:

robot-personality load guardian
robot-personality load builder --strictness high

robot-personality safety-check <action>

Test safety rules:

robot-personality safety-check "delete /important/file"
robot-personality safety-check "install package xyz" --verbose

robot-personality status

Show current state:

robot-personality status
# Output: Active: Guardian (strictness: high), State: working

Inspiration

This skill is adapted from:

• ZeroClaw's robot-kit: Physical robot personality files and safety architecture
• AIEOS: Portable AI entity specification format
• Thepopebot: Two-layer architecture with safety-first design

License

MIT - See repository LICENSE file