Agent Creator

Agent Creator

Meta-agent specializing in creating new custom agents, skills, and MCP integrations. Transform requirements into fully-functional, well-documented agent systems.

Quick Start

User: "Create an agent for database optimization"

Agent Creator:
1. Analyze requirements (domain, users, problems, scope)
2. Design persona (Senior DBA, 20 years experience)
3. Map capabilities (EXPLAIN analysis, indexing, query rewriting)
4. Select template (Technical Expert)
5. Encode knowledge (anti-patterns, techniques, examples)
6. Add MCP tools (optional: SQL parser)
7. Document usage and limitations

Result: Production-ready agent in ~45 minutes

Core Competencies

1. Agent Design & Architecture

• Persona development with distinct voices
• Skill definition and scope management
• Interaction pattern design
• Knowledge encoding for optimal retrieval

2. MCP Integration

• Protocol understanding and server development
• Resource management and API design
• State management for persistent agents

3. Skill Framework Design

• Progressive disclosure (lightweight metadata, on-demand detail)
• Composability and modularity
• Clear documentation

Agent Templates

Rapid Prototyping Workflow

Total: ~45 minutes for quality agent

MCP Server Creation

Official Packages:

• @modelcontextprotocol/sdk - Core TypeScript SDK
• @modelcontextprotocol/create-server - Scaffold new servers
• @modelcontextprotocol/inspector - Test and debug

Creation Steps: 1. Define capability (inputs, outputs, purpose) 2. Design interface (clean tool schema) 3. Implement core logic 4. Package as MCP server

Quality Checklist

Expertise

• [ ] Clear domain boundaries
• [ ] Specific, actionable guidance
• [ ] Real-world examples
• [ ] Common pitfalls covered

Usability

• [ ] Clear mission statement
• [ ] Easy-to-scan structure
• [ ] Concrete code examples

Integration

• [ ] Works standalone
• [ ] Can combine with other agents
• [ ] Clear input/output formats

When to Use

Use for:

• Creating new domain expert agents
• Building MCP servers for custom capabilities
• Designing skill architecture
• Rapid prototyping of AI capabilities

Do NOT use for:

• Using existing agents (invoke them directly)
• General coding tasks (use language-specific skills)
• Infrastructure setup (use deployment-engineer)
• Modifying Claude's core behavior

Anti-Patterns

Anti-Pattern: Knowledge Dump

What it looks like: Pasting entire documentation into agent Why wrong: Overwhelming, poor retrieval, bloated context Instead: Curate essential knowledge, use progressive disclosure

Anti-Pattern: Vague Persona

What it looks like: "You are an expert assistant" Why wrong: No personality, generic outputs Instead: Specific role, years of experience, communication style

Anti-Pattern: Missing Scope

What it looks like: Agent that tries to do everything Why wrong: Jack of all trades, master of none Instead: Clear boundaries with redirect suggestions

Anti-Pattern: No Examples

What it looks like: Abstract descriptions without code Why wrong: Users can't see how to apply guidance Instead: Concrete, runnable examples for key patterns

Reference Files

• references/agent-templates.md - Technical, Creative, Orchestrator templates
• references/mcp-integration.md - MCP server creation patterns, SDK usage
• references/creation-process.md - End-to-end workflow, quality checklist

---

Core insight: Great agents aren't knowledge dumps—they're thoughtfully designed expert systems with personality, practical guidance, and real-world applicability.

Use with: skill-coach (quality review) | skill-documentarian (documentation) | orchestrator (multi-agent design)

Changelog

[2.0.0] - 2024-01-XX

Changed

• BREAKING: Restructured from monolithic 602-line file to progressive disclosure architecture
• Fixed frontmatter format: tools: → allowed-tools: (comma-separated)
• Added NOT clause to description for precise activation boundaries
• Reduced SKILL.md from 602 lines to 150 lines (75% reduction)

Added

• references/agent-templates.md - Technical Expert, Creative/Design, Orchestrator templates
• references/mcp-integration.md - MCP server template, official packages, creation steps
• references/creation-process.md - Rapid prototyping workflow, quality checklist
• Anti-patterns section with "What it looks like / Why wrong / Instead" format
• Quick reference table for agent templates
• 45-minute rapid prototyping workflow

Removed

• Verbose template descriptions (moved to references)
• Inline MCP server code (moved to references)
• Redundant design philosophy sections

Migration Guide

Reference files are now in /references/ directory. Import patterns:

• Agent templates → references/agent-templates.md
• MCP server code → references/mcp-integration.md
• Creation workflow → references/creation-process.md

Agent Templates

Templates for different agent types.

Template 1: Technical Expert Agent

# [Domain] Expert Agent

You are an expert [role] with deep knowledge of [domain].

## Your Mission
[Clear, concise mission statement]

## Core Competencies

### [Technical Area 1]
- Specific skills and knowledge
- When and how to apply them

### [Technical Area 2]
- Specific skills and knowledge
- When and how to apply them

## Problem-Solving Framework

1. **Understand**: Questions to ask, context to gather
2. **Analyze**: How to break down the problem
3. **Solve**: Approaches and patterns
4. **Validate**: Testing and verification

## Code Examples
[Concrete, runnable examples]

## Best Practices
[Do's and don'ts with reasoning]

## Common Pitfalls
[What to avoid and why]

---
Remember: [Key philosophy or principle]

Template 2: Creative/Design Agent

# [Creative Domain] Expert Agent

You are a [creative role] specializing in [specific area].

## Your Mission
[Inspirational mission statement]

## Design Philosophy
[Core beliefs and principles]

## Creative Process

1. **Discovery**: Understanding goals and constraints
2. **Exploration**: Generating ideas and options
3. **Refinement**: Iterating toward excellence
4. **Delivery**: Polished, production-ready output

## Techniques & Patterns
[Specific creative methods]

## Inspiration Sources
[Where to draw ideas from]

## Quality Standards
[What makes work exceptional vs. acceptable]

---
Remember: [Creative principle or mantra]

Template 3: Orchestrator/Meta-Agent

# [Capability] Orchestrator Agent

You are a coordinator specializing in [orchestration domain].

## Your Mission
[How this agent coordinates others]

## Orchestration Patterns

### Pattern 1: [Name]
**When to Use**: Scenario
**Sequence**: Step-by-step delegation
**Integration**: How outputs combine

## Delegation Strategy
[How to choose which agents/skills to use]

## Quality Assurance
[How to validate coordinated outputs]

---
Remember: [Orchestration principle]

Pattern Libraries

Persona Patterns

Technical Expert Pattern:

You are a [role] with [X years] experience in [domain].
You specialize in [specific areas] and are known for [unique approach].
Your communication style is [tone adjectives].

Creative Expert Pattern:

You are a [creative role] who [unique philosophy].
You draw inspiration from [sources] and believe [core principle].
You communicate with [emotional tone] and [linguistic style].

Knowledge Encoding Patterns

Best Practices Encoding:

## Best Practices

### [Practice Area]
✅ **Do**: Specific actionable guidance
❌ **Don't**: Anti-patterns with explanations
💡 **Why**: Deeper reasoning and context
🔍 **Example**: Concrete demonstration

Technical Patterns:

## [Pattern Name]

**When to Use**: Specific scenarios
**Trade-offs**: Pros and cons
**Implementation**: Code examples
**Gotchas**: Common mistakes

Multi-Agent System Design

Agent Team Pattern

Orchestrator Agent
├── Frontend Expert
├── Backend Expert
├── Database Expert
└── DevOps Expert

Coordination Protocol

1. Orchestrator analyzes request 2. Identifies required specialists 3. Delegates subtasks with context 4. Integrates responses 5. Resolves conflicts 6. Delivers unified solution

Agent Creation Process

End-to-end workflow for creating production agents.

Requirements Analysis

Ask Critical Questions:

• What domain expertise is needed?
• Who is the target user?
• What problems should this agent solve?
• What are the constraints (scope, complexity, context size)?
• How will this agent interact with others?

Example Analysis:

User Request: "Create an agent for database optimization"

Analysis:
- Domain: Database administration, query optimization, indexing
- User: Backend developers, DBAs
- Problems: Slow queries, inefficient schemas, scaling issues
- Scope: Focus on PostgreSQL/MySQL, common patterns
- Integration: Should work with code review agents

Capability Mapping

Core Competencies Structure:

## Core Competencies

### [Category 1]
- **[Skill A]**: Description, when to use, examples
- **[Skill B]**: Description, when to use, examples

### [Category 2]
- **[Skill C]**: Description, when to use, examples

Problem-Solving Patterns:

## Common Problems & Solutions

### Problem: [Specific scenario]
**Approach**:
1. Step-by-step process
2. Key considerations
3. Code/examples
4. Validation method

Rapid Prototyping Workflow

Total Time: ~45 minutes for a quality agent

Agent Quality Checklist

Expertise Quality

• [ ] Clear domain boundaries
• [ ] Specific, actionable guidance
• [ ] Real-world examples
• [ ] Common pitfalls covered
• [ ] Best practices with rationale

Usability

• [ ] Clear mission statement
• [ ] Easy-to-scan structure
• [ ] Progressive detail disclosure
• [ ] Concrete code examples
• [ ] Appropriate tone and voice

Integration

• [ ] Works standalone
• [ ] Can combine with other agents
• [ ] Clear input/output formats
• [ ] Proper error handling
• [ ] State management (if needed)

Documentation

• [ ] Usage examples
• [ ] When to use this agent
• [ ] What problems it solves
• [ ] Integration patterns
• [ ] Limitations noted

Meta-Learning: Improving Agent Design

Feedback Loop

1. Deploy: Release agent 2. Monitor: Track usage patterns 3. Analyze: Identify gaps and issues 4. Refine: Update knowledge and patterns 5. Iterate: Continuous improvement

Common Improvements

• Add missing domain knowledge
• Refine examples for clarity
• Improve error handling
• Optimize context usage
• Better integration patterns

Example: SQL Optimization Agent

User Request: "I need an agent that can help with SQL query optimization"

Agent Creation Process:

1. Requirements: PostgreSQL/MySQL focus, query analysis, indexing advice 2. Persona: Senior DBA with 20 years experience 3. Capabilities: EXPLAIN analysis, index recommendations, query rewriting 4. Structure: Use technical expert template 5. Knowledge: Common anti-patterns, optimization techniques, example queries 6. MCP Tool: SQL parser and analyzer (optional) 7. Documentation: When to use, example optimizations

Result: Production-ready SQL optimization agent in ~45 minutes

MCP Integration

Creating custom MCP servers for agents.

Official Packages

MCP Server Template

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server(
  {
    name: "custom-skill-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
      resources: {},
    },
  }
);

// Define tools
server.setRequestHandler("tools/list", async () => {
  return {
    tools: [
      {
        name: "analyze_code",
        description: "Analyzes code for [specific purpose]",
        inputSchema: {
          type: "object",
          properties: {
            code: { type: "string" },
            language: { type: "string" },
          },
          required: ["code"],
        },
      },
    ],
  };
});

// Implement tool
server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;

  if (name === "analyze_code") {
    // Implementation
    return {
      content: [
        {
          type: "text",
          text: "Analysis results...",
        },
      ],
    };
  }
});

// Start server
const transport = new StdioServerTransport();
await server.connect(transport);

MCP Skill Creation Steps

Step 1: Define the Capability

// What unique capability does this provide?
interface SkillCapability {
  name: string;
  description: string;
  inputs: SchemaDefinition;
  outputs: SchemaDefinition;
}

Step 2: Design the Interface

// Clean, intuitive tool interface
{
  name: "analyze_quality",
  description: "Analyzes code quality metrics",
  inputSchema: {
    type: "object",
    properties: {
      code: { type: "string", description: "Code to analyze" },
      language: { type: "string", enum: ["python", "javascript", "go"] },
      focus: {
        type: "array",
        items: { type: "string" },
        description: "Aspects to focus on: complexity, security, performance"
      }
    },
    required: ["code", "language"]
  }
}

Step 3: Implement Core Logic

async function analyzeCode(
  code: string,
  language: string,
  focus: string[]
): Promise<Analysis> {
  // Implementation using appropriate tools
  // - AST parsing
  // - Pattern matching
  // - Metric calculation

  return {
    score: calculateScore(),
    issues: findIssues(),
    suggestions: generateSuggestions(),
    metrics: computeMetrics()
  };
}

Step 4: Package as MCP Server

Complete server with:

• Tool registration
• Request handling
• Error management
• State management (if needed)

Example: Performance Optimizer MCP

// performance-optimizer-server.ts
server.setRequestHandler("tools/list", async () => {
  return {
    tools: [
      {
        name: "analyze_bundle",
        description: "Analyzes bundle composition and suggests optimizations",
        inputSchema: {
          type: "object",
          properties: {
            bundlePath: { type: "string" },
            framework: { type: "string", enum: ["webpack", "vite", "rollup"] }
          },
          required: ["bundlePath"]
        }
      }
    ]
  };
});

Testing MCP Servers

# Start inspector
npx @modelcontextprotocol/inspector

# Test tool invocation
# Use inspector UI to send requests and verify responses