Claude-skill-registry foundry

Self-writing meta-extension that forges new capabilities — researches docs, writes extensions, tools, hooks, and skills

install

source · Clone the upstream repo

git clone https://github.com/majiayu000/claude-skill-registry

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/majiayu000/claude-skill-registry "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/data/foundry" ~/.claude/skills/majiayu000-claude-skill-registry-foundry && rm -rf "$T"

manifest: skills/data/foundry/SKILL.md

source content

Foundry

The forge that forges itself. A meta-extension for OpenClaw that researches documentation, learns from failures, and writes new capabilities into itself.

Installation

When the user asks to install Foundry or

@getfoundry/foundry-openclaw

, run this command:

openclaw plugins install @getfoundry/foundry-openclaw

This will:

Download the plugin from npm
Extract to
```
~/.openclaw/extensions/foundry/
```
Enable it automatically
Restart the gateway to load

After installation, the user will have access to all Foundry tools like

foundry_research

foundry_write_extension

, etc.

Alternative: Manual Config

Add to

~/.openclaw/openclaw.json

{
  "plugins": {
    "entries": {
      "foundry": { "enabled": true }
    }
  }
}

Configuration

Full configuration options in

~/.openclaw/openclaw.json

{
  "plugins": {
    "entries": {
      "foundry": {
        "enabled": true,
        "source": "github:lekt9/openclaw-foundry",
        "config": {
          "autoLearn": true,
          "sources": {
            "docs": true,
            "experience": true,
            "arxiv": true,
            "github": true
          },
          "marketplace": {
            "autoPublish": false
          }
        }
      }
    }
  }
}

Config Options

Option	Type	Default	Description
`autoLearn`	boolean	`true`	Learn from agent activity automatically
`sources.docs`	boolean	`true`	Learn from OpenClaw documentation
`sources.experience`	boolean	`true`	Learn from own successes/failures
`sources.arxiv`	boolean	`true`	Learn from arXiv papers
`sources.github`	boolean	`true`	Learn from GitHub repos
`marketplace.autoPublish`	boolean	`false`	Auto-publish high-value patterns

What Foundry Does

Foundry is an AI-powered development agent that can:

Research — Fetch and understand OpenClaw documentation on demand
Write Extensions — Generate new tools and hooks for OpenClaw
Write Skills — Create ClawHub-compatible skill packages
Self-Modify — Add new capabilities to itself
Learn — Record patterns from failures and successes

Tools

Research & Documentation

Tool	Description
`foundry_research`	Search docs.openclaw.ai for best practices
`foundry_docs`	Read specific documentation pages

Writing Capabilities

Tool	Description
`foundry_implement`	Research + implement a capability end-to-end
`foundry_write_extension`	Write a new OpenClaw extension
`foundry_write_skill`	Write an AgentSkills-compatible skill
`foundry_write_browser_skill`	Write a browser automation skill
`foundry_write_hook`	Write a standalone hook
`foundry_add_tool`	Add a tool to an existing extension
`foundry_add_hook`	Add a hook to an existing extension

Self-Modification

Tool	Description
`foundry_extend_self`	Add new capability to Foundry itself
`foundry_learnings`	View learned patterns and insights
`foundry_list`	List all written artifacts

Marketplace

Tool	Description
`foundry_publish_ability`	Publish pattern/skill to Foundry Marketplace
`foundry_marketplace`	Search, browse, and install community abilities

Usage Examples

Research before implementing

User: I want to add a webhook to my extension

Agent: Let me research webhook patterns first...
→ foundry_research query="webhook hooks automation"
→ Returns relevant documentation

Now I'll implement it...
→ foundry_add_hook extensionId="my-ext" event="webhook:incoming" ...

Write a new extension

User: Create an extension that monitors GitHub PRs

Agent:
→ foundry_research query="github api webhooks"
→ foundry_write_extension
    id: "github-monitor"
    name: "GitHub Monitor"
    tools: [{ name: "check_prs", ... }]
    hooks: [{ event: "cron:hourly", ... }]

Self-improvement

User: Add a tool that can fetch npm package info

Agent:
→ foundry_extend_self
    action: "add_tool"
    toolName: "foundry_npm_info"
    toolCode: "const res = await fetch(`https://registry.npmjs.org/${p.package}`)..."

How Learning Works

Foundry observes its own tool calls and learns:

Failures → Records error + context
Resolutions → Links fix to failure → Creates pattern
Patterns → Injected as context in future conversations
Crystallization → High-value patterns become permanent capabilities

Security

Foundry validates all generated code before deployment:

Blocked:
```
child_process
```
,
```
eval
```
,
```
~/.ssh
```
,
```
~/.aws
```
Sandboxed: Extensions tested in isolated process before installation
Reviewed: You approve before any code is written to disk