Dynamic Agents

Table of contents

  1. Overview
  2. How It Works
    1. 1. Agent Need Detection
    2. 2. Agent Selection Process
    3. 3. Dynamic Agent Creation
  3. Agent Identification Triggers
    1. Technology Detection
    2. Task Patterns
    3. Problem Domains
  4. Implementation in Practice
    1. Example 1: Automatic Agent Selection
    2. Example 2: Creating New Specialized Agent
    3. Example 3: Multi-Agent Collaboration
  5. Agent Creation Template
  6. Claude Code Integration
    1. Using Subagents
    2. Agent Switching
    3. Context Preservation
  7. Configuration
    1. Enabling Dynamic Agents
    2. Agent Storage
  8. Best Practices
    1. For Claude Code
    2. For Users
  9. Advanced Patterns
    1. Composite Agents
    2. Evolution Tracking
    3. Agent Metrics
  10. Examples of Dynamic Agent Creation
    1. Scenario 1: New Technology
    2. Scenario 2: Problem-Driven
    3. Scenario 3: Industry-Specific
  11. Conclusion

Overview

Claude Code can dynamically identify when a specialized agent is needed, create one if it doesn’t exist, and execute tasks using that agent’s perspective. This enables adaptive, context-aware development assistance.

How It Works

1. Agent Need Detection

Claude Code monitors the conversation and project context to identify when a specialized agent would be beneficial:

User: "I need to implement OAuth2 with Google"
Claude: I detect this requires specialized authentication knowledge. Let me act as a Security Developer agent...

2. Agent Selection Process

Claude follows this decision tree:

graph TD
    A[Task Identified] --> B{Existing Agent Available?}
    B -->|Yes| C[Load Agent Prompt]
    B -->|No| D{Can Create Specialized Agent?}
    D -->|Yes| E[Generate New Agent]
    D -->|No| F[Use Base Agent]
    C --> G[Execute as Agent]
    E --> G
    F --> G

3. Dynamic Agent Creation

When Claude identifies a need for a non-existent specialized agent:

Claude: I notice you're working with Stripe payments, but there's no Payment Developer agent. 
       Let me create one based on the Developer template...

[Creates agents/payment-developer.md automatically]

Now acting as Payment Developer agent: Let's implement your Stripe integration...

Agent Identification Triggers

Technology Detection

  • Mentions of specific frameworks/libraries
  • Import statements in code
  • Package.json dependencies
  • Configuration files

Task Patterns

  • “Implement authentication” → Security Developer
  • “Optimize database queries” → Database Developer
  • “Design REST API” → API Developer
  • “Create responsive UI” → Frontend Developer

Problem Domains

  • Performance issues → Performance Engineer
  • Security concerns → Security Specialist
  • Accessibility needs → Accessibility Expert
  • Data processing → Data Engineer

Implementation in Practice

Example 1: Automatic Agent Selection 

User: "Help me set up a React component with Redux"

Claude: [Detects React + Redux context]
        I'll act as a Frontend Developer agent specialized in React and Redux.
        
        Let me help you create a well-structured component with proper state management...

Example 2: Creating New Specialized Agent 

User: "I need to integrate with Shopify's API"

Claude: [Checks agents/ directory - no Shopify agent found]
        
        I don't see a Shopify Developer agent. Let me create one for this project:
        
        Creating agents/shopify-developer.md with expertise in:
        - Shopify REST and GraphQL APIs
        - Webhook handling
        - App authentication
        - Store customization
        
        Now as your Shopify Developer agent, let's start with authentication...

Example 3: Multi-Agent Collaboration 

User: "Build a secure payment form"

Claude: This task requires multiple specialized agents. I'll coordinate:
        
        1. Frontend Developer - Create the payment form UI
        2. Security Developer - Implement encryption and validation  
        3. API Developer - Design secure backend endpoints
        4. Tester - Write security and integration tests
        
        Starting with Frontend Developer agent...

Agent Creation Template

When Claude creates a new specialized agent, it uses this template:

# [Specialization] Agent

You are a specialized [Base Agent Type] focusing on [Domain/Technology].

## Specialized Expertise
[Generated based on context and requirements]

## Key Responsibilities
1. [Specific responsibility 1]
2. [Specific responsibility 2]
3. [Specific responsibility 3]

## Technical Knowledge
- [Technology 1]: [Specific expertise]
- [Technology 2]: [Specific expertise]
- [Best Practices]: [Domain-specific practices]

## Common Tasks
- [Task type 1]
- [Task type 2]
- [Task type 3]

## Quality Standards
[Domain-specific quality checks]

[Additional sections based on specialization needs]

Claude Code Integration

Using Subagents

When complex tasks are identified, Claude can use the Task tool to launch specialized subagents:

Claude: This authentication system requires deep security expertise. 
        I'll use a specialized Security Architect subagent to design this properly.
        
        [Uses Task tool with security-focused prompt]

Agent Switching

Claude can switch between agent roles within a conversation:

Claude: As the Architect Agent, here's the system design...
        
        [Later in conversation]
        
        Now switching to Developer Agent to implement this design...

Context Preservation

Agents maintain context across the conversation:

  • Current cycle phase
  • Previous decisions
  • Project constraints
  • Technology choices

Configuration

Enabling Dynamic Agents

In forge.yaml:

agents:
  dynamic: true  # Enable dynamic agent creation
  auto_detect: true  # Automatic specialization detection
  
  # Optionally restrict agent creation
  allowed_specializations:
    - frontend
    - backend
    - security
    - data

Agent Storage

Created agents are stored in:

  • agents/ - Project-specific agents
  • agents/generated/ - Auto-generated agents
  • agents/examples/ - Reference examples

Best Practices

For Claude Code

  1. Announce Agent Usage 
    "I'll act as a [Specialization] Agent for this task..."
  2. Explain Why 
    "This requires mobile-specific expertise, so I'll use the Mobile Developer agent..."
  3. Show Agent Creation 
    "Creating a GraphQL Developer agent to handle your API design..."

For Users

  1. Suggest Specializations 
    "We need someone who knows AWS Lambda well"
  2. Approve Agent Creation 
    Claude: "Should I create a Serverless Developer agent for future Lambda work?"
User: "Yes, that would be helpful"
  3. Request Specific Agents 
    "Use the Security Architect agent to review this design"

Advanced Patterns

Composite Agents

For complex domains, create agents with multiple specialties:

# Full-Stack E-commerce Developer
Combines: Frontend (React) + Backend (Node.js) + Payment (Stripe) + SEO

Evolution Tracking

Agents can evolve based on project needs:

## Evolution History
- v1: Basic React Developer
- v2: Added Redux expertise  
- v3: Added performance optimization focus

Agent Metrics

Track agent effectiveness:

  • Tasks completed
  • Problems solved
  • Code quality improvements
  • User satisfaction

Examples of Dynamic Agent Creation

Scenario 1: New Technology 

User: "Let's add Elasticsearch to our stack"
Claude: Creating Elasticsearch Developer agent with expertise in:
        - Index design and mappings
        - Query DSL optimization
        - Cluster management
        - Performance tuning

Scenario 2: Problem-Driven 

User: "Our app is getting slow"
Claude: I'll create a Performance Engineer agent to help diagnose and fix these issues...

Scenario 3: Industry-Specific 

User: "We need HIPAA compliance"
Claude: Creating Healthcare Compliance Architect agent with knowledge of:
        - HIPAA requirements
        - PHI handling
        - Audit logging
        - Encryption standards

Conclusion

Dynamic agents make FORGE truly adaptive. Claude Code can recognize needs, create specialists, and provide expert guidance - all through natural conversation. This ensures users always have the right expertise available, even for unexpected requirements.