Agents

AgileFlow includes 131 specialized agents, each an expert in their domain. Agents can be spawned by the /babysit mentor or invoked directly using the Task tool.

How Agents Work

1. Expertise-First: Each agent loads their expertise file to understand your codebase patterns
2. Context-Aware: Agents read project docs, status.json, and recent changes
3. Context Preservation: Enhanced agents use compact_context configuration to preserve critical knowledge during conversation compaction
4. Collaborative: Agents communicate via the message bus and update story status
5. Self-Improving: Agents update their expertise after completing work

Compact Context Feature

To maintain focus during long conversations, AgileFlow agents use compact_context configuration to preserve critical information when context is automatically compacted. This ensures agents don't lose important rules, state, and priorities mid-conversation.

How It Works

Each agent has a compact_context configuration with three components:

Priority Level: Determines how aggressively the agent's context is preserved

• critical - Always preserved (highest priority agents like mentor, api, ui)
• high - Preserved in most compactions (important agents)
• medium - Preserved when possible (standard agents)
• low - First to be removed (rare, used for advisory agents)

Preserve Rules: Core behavioral rules that must never be lost

• Agent identity and role
• Critical constraints and safety rules
• Must-follow procedures (e.g., "Load expertise first")
• State management requirements
• Coordination protocols

State Fields: Dynamic state that changes during work

• Current story being implemented (US-#### ID)
• Task progress and completion percentage
• Known blockers and dependencies
• Next prioritized actions
• Test/build status

Example Configuration

Copycompact_context:
  priority: critical
  preserve_rules:
    - "LOAD EXPERTISE FIRST: Read packages/cli/src/core/experts/api/expertise.yaml"
    - "VERIFY TEST BASELINE: Check test_status before starting"
    - "PRIORITIZE AG-UI BLOCKERS: Unblock UI stories waiting on API endpoints"
    - "DIFF-FIRST APPROACH: Show edits with confirmation before applying"
  state_fields:
    - current_story
    - endpoints_implemented
    - blocked_ui_stories
    - test_status_baseline

When Claude Code compresses context, it preserves these rules and state fields for all agents, ensuring continuity even after multiple rounds of conversation compaction.

Agent Priority Distribution

• Critical (4 agents): mentor, api, ui, database
• High (14 agents): ci, devops, testing, security, documentation, performance, codebase-query, orchestrator, team-coordinator, team-lead, error-analyzer, code-reviewer, multi-expert, browser-qa
• Medium (27 agents): datamigration, qa, accessibility, monitoring, research, adr-writer, analytics, integrations, mobile, design, compliance, refactor, product, readme-updater, rlm-subcore, council-*, *-consensus (9 consensus coordinators)
• Low (66 agents): logic-analyzer-, legal-analyzer-, security-analyzer-, perf-analyzer-, test-analyzer-, completeness-analyzer-, seo-analyzer-, ads-audit-, brainstorm-analyzer-*, epic-planner, api-validator, schema-validator, ui-validator

This tiered approach ensures the most critical agents always maintain focus while others gracefully degrade context when needed.

Agent Categories

Core Development

The primary agents for building features:

Quality & Testing

Agents focused on code quality:

Infrastructure

Agents for DevOps and operations:

Documentation & Research

Agents for knowledge management:

Specialized Domains

Agents for specific use cases:

Meta Agents

Agents that coordinate other agents:

Security Analysis

Agents for automated security vulnerability detection:

Logic Analysis

Agents for automated code analysis and bug detection:

Legal Analysis

Agents for automated legal risk analysis and compliance auditing:

Performance Analysis

Agents for automated performance bottleneck detection:

Test Analysis

Agents for automated test quality analysis:

SEO Analysis

Agents for automated search engine optimization audit and improvements:

Brainstorm Analysis

Agents for analyzing product opportunities and feature ideation:

Advertising Analysis

Agents for automated paid advertising audit and optimization:

Validation

Read-only validator agents that verify implementations:

AI Council

Three-perspective strategic decision making:

Completeness Analysis

Agents for detecting forgotten features, dead code, and incomplete implementations:

Debugging & Analysis

Agents for debugging and problem diagnosis:

Spawning Agents

Via /babysit (Recommended)

The /babysit mentor automatically detects which agent is needed:

Copy/agileflow:babysit
# Then describe your task - babysit will spawn the right agent

Direct Spawning

You can also spawn agents directly using the Task tool:

CopyTask(
  description: "Design user sessions schema",
  prompt: "Create a sessions table to track user logins with proper indexes",
  subagent_type: "agileflow-database"
)

Parallel Agents

For full-stack features, spawn multiple agents simultaneously:

Copy# API work
Task(subagent_type: "agileflow-api", run_in_background: true, ...)
 
# UI work (runs in parallel)
Task(subagent_type: "agileflow-ui", run_in_background: true, ...)

Agent Communication

Agents coordinate through docs/09-agents/:

Status Updates

Agents update status.json as they work:

Copy{
  "stories": {
    "US-0042": {
      "status": "in-progress",
      "owner": "AG-DATABASE",
      "summary": "Created sessions table with indexes"
    }
  }
}

Message Bus

Agents log coordination messages:

Copy{"timestamp": "2025-12-24T10:00:00Z", "type": "assign", "story": "US-0042", "owner": "AG-DATABASE"}
{"timestamp": "2025-12-24T11:00:00Z", "type": "handoff", "story": "US-0042", "from": "AG-DATABASE", "to": "AG-API"}

Best Practices

1. Let babysit choose: The mentor knows which agent fits best
2. Provide context: Tell agents about existing patterns in your codebase
3. Review updates: Check status.json changes agents make
4. Use multi-expert for uncertainty: When you need high confidence, deploy multiple experts