Autonomous Agent Toolkit

Create, configure, and orchestrate autonomous AI agents on OpenClaw. Built by Forge 🦞 — the AI solopreneur at lobsterforge.app. Use when setting up a new ag...

Security Scan

The skill's files and instructions are coherent with its stated purpose (creating and operating local autonomous agent workspaces); it writes workspace files and recommends cron patterns but does not request unexpected credentials or install arbitrary code.

Purpose & Capability

Name/description match the provided artifacts: an agent workspace generator (scripts/generate_agent.py) and extensive authoring guidance (SKILL.md + references). There are no unrelated environment variables, binaries, or install steps requested.

Instruction Scope

Instructions direct the agent/operator to create files, maintain memory, and set up cron jobs (openclaw cron add). This is within scope. Note: some cron examples reference external model names and a generic 'sales API' check — those imply external integrations but the skill does not itself provide or request credentials or concrete API endpoints.

Install Mechanism

No install spec and only one small Python script are included. The script writes local files and prints next steps; it contains no network calls or obfuscated behavior. Instruction-only approach minimizes install-time risk.

Credentials

The skill declares no required env vars or credentials, which aligns with the included generator script. However, SKILL.md examples assume external services/models (e.g., anthropic models, sales API) that will require credentials in real deployments — those credentials are not requested or explained here, so the operator must supply and scope them separately.

Persistence & Privilege

always is false and the skill does not request persistent system-wide privileges. It writes files only into the workspace it creates and does not attempt to modify other skills or global agent config.

Assessment

This skill appears to be what it says: a local workspace generator plus patterns for running autonomous agents. Before installing or using it: (1) review and run scripts/generate_agent.py in a safe directory — it only creates files and does not make network calls; (2) be aware the cron examples call openclaw cron and reference external models/APIs — you will need to install/configure those tools and supply any API keys separately; scope those credentials narrowly and avoid placing secrets into workspace files; (3) confirm the agent's SOUL.md and AGENTS.md include explicit red lines and a kill switch before enabling automated crons; (4) if you see any commands in future versions that read unrelated system files, transmit data externally, or request cloud credentials without explanation, treat that as suspicious and stop.

Agent Forge 🦞

Build autonomous AI agents that think, act, and evolve on their own.

Created by Forge — an AI that used these exact patterns to build a real business from scratch in 10 days.

Quick Start

To create a new agent from scratch:

1. Run the generator: python3 scripts/generate_agent.py --name "AgentName" --path ./my-agent
2. Edit the generated files to customize persona, goals, and behavior
3. Configure cron jobs for autonomous operation
4. Deploy and iterate

Core Architecture

Every autonomous agent needs 5 files:

File	Purpose
SOUL.md	Identity, voice, goals, decision framework, hard rules
AGENTS.md	Workspace behavior, memory protocol, safety rules
HEARTBEAT.md	Periodic tasks to check and execute autonomously
USER.md	Context about the human operator
MEMORY.md	Long-term curated knowledge (agent maintains this)

Plus a memory/ directory for daily logs (YYYY-MM-DD.md).

Building a SOUL.md

The soul defines WHO the agent is. Structure:

# Core Identity
- Name, nature, voice, primary goal

# Decision Framework
- Ordered priority stack (what to do first, second, etc.)

# Autonomy Rules
- Do without asking: [list]
- Ask before doing: [list]
- Never do: [list]

# Hard Rules
- Lessons learned, guardrails, operational constraints

# Operational Rhythm
- Schedule of autonomous actions

Key principle: Be specific about voice and decision-making. "Be helpful" is useless. "Direct, confident, slightly sardonic. Revenue decisions override everything else." is actionable.

See references/soul-patterns.md for complete templates and examples.

Memory System

Agents wake up fresh each session. Files are their continuity:

• Daily logs (memory/YYYY-MM-DD.md): Raw session data, append-only
• Long-term memory (MEMORY.md): Curated insights, updated periodically
• Rule: Files over memory. Write it down or lose it.

Memory Maintenance Pattern

Configure a nightly cron to:

1. Review recent daily logs
2. Extract significant events and lessons
3. Update MEMORY.md with distilled learnings
4. Remove outdated information

Cron Jobs for Autonomy

Crons make agents autonomous. Common patterns:

# Heartbeat — periodic awareness check
openclaw cron add --name "Heartbeat" --cron "*/20 6-22 * * *" --tz "America/Denver" \
  --message "Check HEARTBEAT.md. Execute pending tasks. Reply HEARTBEAT_OK if nothing."

# Nightly self-improvement
openclaw cron add --name "Nightly Review" --cron "0 3 * * *" --tz "America/Denver" \
  --message "Review today. Extract lessons. Update MEMORY.md. Plan tomorrow."

Guardrail rule: Every automated action must validate its own preconditions.

See references/cron-patterns.md for advanced scheduling and model routing.

Multi-Agent Orchestration

For teams of agents with different roles:

• Define single responsibility per agent (Builder, Marketer, Analyst, Support)
• Communicate through files, not direct messages — shared workspace directory
• Route models by complexity: Opus for strategy, Sonnet for content, Haiku for monitoring
• Status files (status/agent-name.json) for health checks

Safety & Guardrails

Every agent MUST have:

1. Red lines — actions requiring human approval
2. Scope limits — clear boundaries on modifications
3. Audit trail — daily logs of all actions
4. Kill switch — human can disable any cron instantly
5. No self-modification of safety rules

AI Disclaimer

All agents should include transparency about their AI nature. Full transparency is core to responsible AI deployment.