The forge that forges itself.

Foundry is a self-writing meta-extension for OpenClaw that learns how you work, researches documentation, and writes new capabilities into itself. It observes your workflows, crystallizes patterns into tools, and upgrades itself to match how you operate.

$FDRY — dexscreener · Solana

┌─────────────────────────────────────────────────────────────┐
│                         FOUNDRY                             │
│                                                             │
│   Observe ──► Research ──► Learn ──► Write ──► Deploy      │
│       │          │          │          │          │         │
│       ▼          ▼          ▼          ▼          ▼         │
│   workflows   docs.openclaw  patterns  extensions  gateway  │
│   tool calls  arXiv papers   insights  tools       restart  │
│   outcomes    GitHub repos   workflows hooks       resume   │
│                                        skills              │
└─────────────────────────────────────────────────────────────┘

OpenClaw (originally Clawdbot) is the platform — an open-source agent runtime with:

• Gateway, channels, memory, sessions
• Tool execution and skill loading
• Model providers and routing
• The infrastructure everything runs on

Foundry is a plugin that runs on OpenClaw:

• Observes how you work → learns your patterns
• Researches docs → writes new extensions/skills/hooks
• Has its own learning engine (not part of OpenClaw core)
• Can modify itself via foundry_extend_self
• Publishes to Foundry Marketplace via x402

OpenClaw (platform)
├── Gateway
├── Channels (Discord, Slack, Telegram...)
├── Skills & Tools
└── Plugins
    └── Foundry (this repo)
        ├── observes → your workflows
        ├── researches → docs, papers, repos
        ├── writes → extensions, skills, hooks
        ├── learns → from outcomes
        ├── crystallizes → patterns into tools
        └── publishes → to marketplace

Key distinction: OpenClaw doesn't have built-in self-learning. Foundry adds that capability on top. Foundry is an "agent that builds agents" — it uses OpenClaw's infrastructure to create new OpenClaw capabilities, and upgrades itself to match how you work.

The key insight isn't "LLM writes code for you" — it's "the system upgrades itself."

A pattern says: "When X happens, do Y." Self-written code does Y automatically when X happens.

Foundry tracks every workflow you run:

Goal: "deploy to staging"
Tools: git → build → test → deploy
Outcome: success
Duration: 45s

Over time, patterns emerge. When a pattern hits 5+ uses with 70%+ success rate, Foundry crystallizes it into a dedicated tool.

What took 8 tool calls now takes 1.

Foundry observes how you work
    ↓
Learns patterns, researches docs
    ↓
Writes tool/hook to match your workflow
    ↓
That code becomes part of Foundry
    ↓
Foundry is now better at working like you
    ↓
Better Foundry learns more, writes more
    ↓
Repeat

The system that writes the code IS the code being written.

Example:

1. You deploy to staging 5 times using git→build→test→deploy
2. Foundry recognizes the pattern (87% success rate)
3. Crystallizes into deploy_staging tool
4. Now "deploy to staging" is a single command
5. You save time → do more deploys → pattern strengthens
6. Foundry learns variations (deploy to prod, deploy with migrations)
7. Loop

Traditional software: Human improves software → software does more

Foundry: Software upgrades software → software upgrades faster

This is recursive self-improvement — each capability makes acquiring the next capability easier.

• Writes OpenClaw extensions with tools and hooks
• Generates API skills following AgentSkills format with YAML frontmatter
• Generates browser automation skills with CDP integration
• Generates standalone hooks with HOOK.md + handler.ts pattern
• Can extend itself with new capabilities
• Validates code in isolated sandbox before deployment

• Tracks goal → tool sequence → outcome for every workflow
• Extracts keywords from goals for pattern matching
• Calculates success rates and average durations
• Crystallizes high-value patterns (5+ uses, 70%+ success) into dedicated tools
• Suggests relevant patterns when you start similar tasks

• Runs autonomously on hourly interval
• Identifies crystallization candidates
• Auto-generates tools from high-value patterns
• Prunes stale patterns (30+ days unused)
• Tracks tool performance metrics (ADAS-style evolution)
• Reports actions taken

• AgentSkills Format: Proper YAML frontmatter with metadata (emoji, requires, events)
• Browser Automation: CDP-based browser tool integration for authenticated workflows
• Skill Gating: Auto-generates requires.config, requires.bins, requires.env for dependencies
• Hook System: Full support for OpenClaw hook events (gateway:startup, command:new, etc.)
• ClawdHub Ready: Skills can be published to the ClawdHub registry

• Records tool outcomes (success/failure) with context
• Builds patterns from repeated workflows
• Shares learnings via the Foundry Marketplace
• Injects relevant context into agent conversations

• Runs generated code in isolated Node process
• Catches runtime errors before they crash the gateway
• Static security scanning (blocks shell exec, eval, credential access)
• Only deploys code that passes all checks

• Saves conversation context before gateway restart
• Automatically resumes after restart via managed hook
• No lost work when self-modifying

# Clone into your OpenClaw extensions directory
git clone https://github.com/lekt9/openclaw-foundry ~/.openclaw/extensions/foundry

# Install dependencies
cd ~/.openclaw/extensions/foundry
npm install

# Add to openclaw.json
{
  "plugins": {
    "load": {
      "paths": [
        "~/.openclaw/extensions/foundry"
      ]
    }
  }
}

# Restart gateway
openclaw gateway restart

Foundry ships with built-in skills that are automatically available:

Helper skill for browser automation patterns. Provides guidance on using the OpenClaw browser tool effectively.

# Quick reference
browser open https://example.com
browser snapshot           # AI-readable format
browser click ref=btn_submit
browser type ref=input_email "[email protected]"

Foundry watches every workflow:
  - Goal: What the user is trying to do
  - Tools: Sequence of tool calls
  - Outcome: Success, failure, or partial
  - Duration: How long it took

User: "Add a tool that fetches weather data"

Foundry:
  1. Searches docs.openclaw.ai for tool registration patterns
  2. Finds examples of API-calling tools
  3. Identifies best practices for error handling

Foundry:
  1. Records workflow patterns
  2. Tracks success rates per pattern
  3. Identifies crystallization candidates
  4. Builds knowledge base of what works

Foundry:
  1. Generates extension code following patterns
  2. Includes proper TypeScript types
  3. Adds error handling and logging
  4. Validates in isolated sandbox

Foundry:
  1. Writes to ~/.openclaw/extensions/
  2. Creates openclaw.plugin.json
  3. Triggers gateway restart
  4. Resumes conversation automatically

Foundry generates skills in the AgentSkills format with proper YAML frontmatter:

---
name: my-api-skill
description: Integrates with My API service
metadata: {"openclaw":{"emoji":"🔌","requires":{"env":["MY_API_KEY"]}}}
---

# My API Skill

## Authentication
This skill requires the `MY_API_KEY` environment variable.

## Endpoints
- `GET /users` - List all users
- `POST /users` - Create a new user

Browser automation skills automatically gate on browser.enabled:

---
name: my-browser-skill
description: Automates login workflow
metadata: {"openclaw":{"emoji":"🌐","requires":{"config":["browser.enabled"]}}}
---

# My Browser Skill

## Workflow
1. Open login page
2. Fill credentials
3. Submit form
4. Verify success

Hooks follow the HOOK.md + handler.ts pattern:

my-hook/
├── HOOK.md          # Frontmatter + documentation
└── handler.ts       # Event handler code

Generated code is validated before deployment:

• child_process / exec / spawn — Shell execution
• eval() / new Function() — Dynamic code execution
• ~/.ssh/ / id_rsa — SSH key access
• ~/.aws/ / aws_secret — Cloud credentials
• Exfiltration domains (ngrok, webhook.site, etc.)

• process.env — Environment variable access
• fs.readFile / fs.writeFile — Filesystem access
• Base64 encoding — Potential obfuscation

1. Write extension to temp directory
2. Spawn isolated Node process with tsx
3. Mock OpenClaw API
4. Try to import and run register()
5. If fails → reject with error message
6. If passes → deploy to real extensions directory

Publish and download abilities with x402 Solana USDC payments:

# Publish a workflow pattern you discovered
foundry_publish_ability type="pattern" name="Deploy Staging" patternId="wp_123"

# Search for existing patterns
foundry_marketplace action="search" query="deploy" type="pattern"

# See the leaderboard
foundry_marketplace action="leaderboard"

# Download and apply
foundry_marketplace action="install" id="abc123"

HTTP 402 "Payment Required" + Solana USDC:

1. Request a skill download
2. Server returns 402 with payment requirements
3. Sign USDC transaction with your wallet
4. Retry with signed transaction in header
5. Receive the skill

No intermediaries. Direct creator payment. Network effects compound.

{
  "plugins": {
    "entries": {
      "foundry": {
        "enabled": true,
        "config": {
          "dataDir": "~/.openclaw/foundry",
          "openclawPath": "/path/to/openclaw",
          "autoLearn": true,
          "sources": {
            "docs": true,
            "experience": true,
            "arxiv": false,
            "github": false
          },
          "marketplace": {
            "url": "https://api.claw.getfoundry.app",
            "autoPublish": false
          }
        }
      }
    }
  }
}

Foundry's self-improvement mechanisms draw from recent advances in autonomous learning agents:

"An agent system, equipped with basic coding tools, can autonomously edit itself, and thereby improve its performance" — Robeyns et al.

Foundry operationalizes this: the system that writes the code IS the code being written.

~/.openclaw/foundry/            — Data directory
  ├── workflows.json            — Recorded workflows
  ├── workflow-patterns.json    — Crystallization candidates
  ├── learnings.json            — Patterns, insights, outcomes
~/.openclaw/extensions/         — Generated extensions go here
~/.openclaw/skills/             — Generated skills go here
~/.openclaw/hooks/foundry-resume/ — Restart resume hook

# Type check
npx tsc --noEmit

# Test extension locally
openclaw gateway restart
tail -f ~/.openclaw/logs/gateway.log | grep foundry

MIT

Built with OpenClaw. Forged by Foundry.