Autonomous Lucid Agent Factory

Fully autonomous pipeline that researches a domain and generates a complete monorepo of 10 production-ready Lucid Agents.

When to Use

Activate this skill when the user wants to:

• "Build agents for [domain]"

• "Create a suite of [domain] agents"

• "Generate autonomous agents for [subject]"

• "Build a monorepo of agents for [industry/topic]"

What This Skill Does

Orchestrates an end-to-end autonomous agent generation pipeline:

• Domain Research - Deep research into the subject area

• Idea Generation - Generate 10 unique agent concepts

• Parallel Agent Creation - Build all 10 agents simultaneously

• Monorepo Organization - Structure as a professional monorepo

• Publishing & Deployment - Git publish and optional Railway deployment

Workflow Architecture

User Input: "cryptocurrency trading" ↓ ┌───────────────────────────────────────────────┐ │ Phase 1: Domain Research (research-agent) │ │ - Best practices and patterns │ │ - Common use cases and pain points │ │ - Technical requirements and constraints │ └───────────────────────────────────────────────┘ ↓ ┌───────────────────────────────────────────────┐ │ Phase 2: Idea Generation │ │ - Analyze research findings │ │ - Generate 10 unique agent concepts │ │ - Validate feasibility and value │ └───────────────────────────────────────────────┘ ↓ ┌───────────────────────────────────────────────┐ │ Phase 3: Parallel Agent Creation │ │ │ │ Agent 1 ──→ /paid-agent ──→ Built + Tested │ │ Agent 2 ──→ /paid-agent ──→ Built + Tested │ │ Agent 3 ──→ /paid-agent ──→ Built + Tested │ │ ... │ │ Agent 10 ─→ /paid-agent ──→ Built + Tested │ │ │ │ (All run in parallel for speed) │ └───────────────────────────────────────────────┘ ↓ ┌───────────────────────────────────────────────┐ │ Phase 4: Monorepo Organization │ │ │ │ domain-agents/ │ │ ├── packages/ │ │ │ ├── agent-1/ │ │ │ ├── agent-2/ │ │ │ └── ... │ │ ├── package.json (workspaces) │ │ ├── tsconfig.base.json │ │ └── README.md (comprehensive) │ └───────────────────────────────────────────────┘ ↓ ┌───────────────────────────────────────────────┐ │ Phase 5: Publishing & Deployment │ │ - Git commit entire monorepo │ │ - Push to GitHub │ │ - Optional: Deploy all to Railway │ └───────────────────────────────────────────────┘

Instructions

Step 1: Gather Requirements

Ask the user for:

• Domain/Subject: What domain to build agents for

• Monorepo name: Repository name (kebab-case)

• Deployment preference: Deploy immediately or later?

AskUserQuestion with:

• "What domain should we build agents for?"
• "What should we name the monorepo?" (suggest based on domain)
• "Deploy all agents to Railway immediately?" (yes/no)

Step 2: Domain Research

Launch research-agent to deeply understand the domain:

Skill("research-agent", args: "Research {DOMAIN} comprehensively. Focus on:

• Common use cases and applications
• Pain points and challenges
• Technical requirements
• Best practices and patterns
• Opportunities for AI agents")

After research completes, immediately proceed to idea generation.

Step 3: Generate 10 Agent Ideas

Using the research findings, generate 10 unique agent concepts:

Criteria for each agent idea:

• Solves a specific problem in the domain

• Has clear value proposition

• Technically feasible as a Lucid Agent

• Complements other agents in the suite

• Has well-defined inputs/outputs

Output format:

1. agent-name-1: Brief description (1 sentence)
2. agent-name-2: Brief description (1 sentence) ...
3. agent-name-10: Brief description (1 sentence)

Present the 10 agent ideas to the user, then immediately proceed to create the monorepo structure and build the agents.

Step 4: Create Monorepo Structure

Create the root monorepo before spawning agents:

mkdir -p {monorepo-name}/packages cd {monorepo-name}

Create root package.json with workspaces

Create tsconfig.base.json

Create .gitignore

Create README.md template

Step 5: Parallel Agent Creation

Spawn 10 paid-agent skills in parallel (single message with multiple Tool calls):

CRITICAL: Use Task tool with run_in_background=true for each agent to run them in parallel.

For each of the 10 agents, spawn in parallel:

Task( subagent_type="general-purpose", description="Build agent {N}", prompt="Use the /paid-agent skill to create: {AGENT_DESCRIPTION}

Target directory: {monorepo-name}/packages/{agent-name}

After paid-agent completes:

• Do NOT push to GitHub (we'll do that for the monorepo)
• Do NOT create a separate repo
• Agent should be in packages/{agent-name}/ directory ", run_in_background=true )

Monitor all 10 agents for completion by using TaskOutput or reading their output files. Once all agents have completed successfully, proceed immediately to integration.

Step 6: Integrate into Monorepo

Once all agents are built:

• Verify structure:

ls -la packages/

Should show all 10 agent directories

• Create root package.json:

{ "name": "{monorepo-name}", "version": "1.0.0", "private": true, "workspaces": [ "packages/" ], "scripts": { "build": "bun run --filter '' build", "test": "bun run --filter '' test", "type-check": "bun run --filter '' type-check", "dev:all": "bun run --filter '*' dev" } }

• Create root tsconfig.base.json:

{ "compilerOptions": { "target": "ES2022", "module": "ESNext", "moduleResolution": "bundler", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "resolveJsonModule": true } }

• Create comprehensive README.md:

• Overview of the agent suite

• Description of each agent

• Installation instructions

• Usage examples

• Development guide

Step 7: Publish Monorepo

cd {monorepo-name} git init git add -A Skill("commit") # Uses /commit skill

Create GitHub repo

gh repo create {monorepo-name} --public --source=. --remote=origin --push --description "{DOMAIN} AI Agent Suite - 10 production Lucid Agents"

Step 8: Deploy (Optional)

If user requested deployment:

For each agent in packages/

for agent in packages/*/; do Skill("railway", args: "deploy $agent") done

Step 9: Summary

Provide the user with:

• GitHub repository URL

• List of all 10 agents with descriptions

• Monorepo structure overview

• Quick start commands

• Next steps (e.g., customize agents, configure payments)

Example Usage

User: "Build agents for cryptocurrency trading"

Assistant response:

1. Ask: "What should we name the monorepo?" (suggest: "crypto-trading-agents")
2. Research domain: Skill("research-agent", args: "Research cryptocurrency trading comprehensively...")
3. Generate 10 agent ideas based on research:
   • price-alert-agent: Monitor crypto prices and send alerts on thresholds
   • portfolio-tracker-agent: Track portfolio performance across exchanges
   • sentiment-analyzer-agent: Analyze crypto social sentiment
   • whale-watcher-agent: Monitor large transactions on-chain
   • arbitrage-finder-agent: Find arbitrage opportunities across DEXs
   • gas-optimizer-agent: Optimize transaction gas fees
   • risk-scorer-agent: Score trading risk for positions
   • trend-predictor-agent: Predict short-term price trends
   • news-aggregator-agent: Aggregate crypto news from multiple sources
   • liquidity-monitor-agent: Monitor liquidity pools and yields
4. Present ideas to user and proceed automatically
5. Create monorepo structure
6. Spawn 10 parallel agents using Task tool with run_in_background=true
7. Monitor all agents and proceed when complete
8. Integrate into monorepo with shared configs
9. Commit and push to GitHub
10. Optionally deploy all to Railway
11. Provide summary with GitHub URL and agent overview

Pipeline Stages

Stage 1: Domain Research (5-10 minutes)

• Deep dive into the domain

• Identify patterns and opportunities

• Gather technical requirements

• Research best practices

Stage 2: Idea Generation (2-3 minutes)

• Synthesize research into agent concepts

• Ensure diversity and complementarity

• Validate feasibility

• Present ideas and proceed automatically

Stage 3: Parallel Agent Creation (30-60 minutes)

• All 10 agents build simultaneously

• Each runs full /paid-agent pipeline:

• Ralph loop #1 (build features)

• Code review

• Ralph loop #2 (fix tests)

• All tests pass

• Running in parallel dramatically reduces total time

Stage 4: Monorepo Organization (5 minutes)

• Create workspace configuration

• Add shared configs

• Generate comprehensive README

• Set up cross-package scripts

Stage 5: Publishing (2 minutes)

• Git commit entire monorepo

• Push to single GitHub repository

• Optional: Deploy all agents

Skill Composition

This meta-skill orchestrates:

• research-agent - Domain research and analysis

• paid-agent (10x) - Complete agent creation pipeline

• commit - Git operations with proper formatting

• railway (10x, optional) - Agent deployment

Key Design Decisions

Why Parallel Execution?

• Building 10 agents sequentially would take 5-10 hours

• Parallel execution with Task tool reduces to 30-60 minutes

• Each agent is independent and can build simultaneously

Why Monorepo?

• Single source of truth for all agents

• Shared configurations and dependencies

• Easier to manage and version

• Better discoverability

• Simpler deployment pipeline

Why 10 Agents?

• Provides comprehensive coverage of the domain

• Creates a valuable agent ecosystem

• Balances breadth vs depth

• Manageable complexity

• Can be adjusted based on user needs

Configuration Options

Agent Count

Default is 10, but can be customized:

• Minimum: 3 agents

• Maximum: 20 agents (be mindful of resource limits)

Deployment Strategy

Options:

• None: Just build and publish to GitHub

• Selective: Deploy only specific agents

• All: Deploy entire suite to Railway

Research Depth

Options:

• Quick: 5-minute research scan

• Standard: 10-minute comprehensive research (default)

• Deep: 20-minute extensive research with examples

Error Handling

If Research Fails

• Retry with simplified query

• Fall back to general domain knowledge

• Ask user for domain expertise

If Agent Creation Fails

• Log which agent failed

• Continue with remaining agents

• Report failures in summary

• Allow retry of failed agents

If Monorepo Integration Fails

• Verify each agent directory exists

• Check for naming conflicts

• Validate package.json in each agent

If Publishing Fails

• Check git authentication

• Verify GitHub repo name is unique

• Ensure all files are committed

Advanced Features

Custom Agent Templates

Allow user to provide template or requirements for specific agents

Dependency Management

Detect and configure shared dependencies across agents

Testing Suite

Generate integration tests for the agent ecosystem

Documentation Generation

Auto-generate API docs for each agent

Limitations

• Maximum 20 agents (resource constraints)

• Each agent must be independent (no cross-dependencies)

• Requires stable internet for parallel research and builds

• Railway deployment requires valid credentials

Required Tools

• research-agent skill

• paid-agent skill

• commit skill

• Task tool (for parallel execution)

• gh CLI (for GitHub operations)

• Railway CLI (optional, for deployment)

• Bun package manager

Performance Estimates

Sequential (old approach)

• 10 agents × 30 min each = 300 minutes (5 hours)

Parallel (this approach)

• Research: 10 minutes

• Idea generation: 5 minutes

• Agent creation (parallel): 30-60 minutes

• Integration: 5 minutes

• Total: ~50-80 minutes

Speedup: 4-6x faster ⚡

See Also

• /research-agent

• Domain research and analysis

• /paid-agent

• Complete agent creation pipeline

• /commit

• Git operations

• Railway skill - Agent deployment