DOCSEARCHbyAlgolia
Submit Docs

Claude Sub-Agents Manager (@webdevtoday/claude-agents)

repository·main·Indexed 41 days ago

https://github.com/webdevtodayjason/sub-agents

A CLI tool for orchestrating 16 specialized AI sub-agents for Claude Code, featuring agent chaining, voice announcements, and shared memory. Version 1.5.5. Note: This project is archived as Claude Code now provides these capabilities natively.

Tokens
44.8K
Snippets
174
Records
215
Agent score
53%

What's inside Claude Sub-Agents Manager

  1. Overview of Claude Sub-Agents core capabilities

    main

    Claude Sub-Agents is an AI-powered development system designed to enhance Claude Code. It provides a team of 15 specialized agents that cover the full software development lifecycle.

    Key features include:

    • Concurrent Execution: Parallel processing for 2-4x performance gains.
    • Shared Memory System: A JSON-based persistence layer with TTL (Time-To-Live) support that allows agents to coordinate and share discoveries automatically.
    • Web Dashboard: A management UI for monitoring agent activity.
    • Specialized Agents: Includes roles such as project-planner, api-developer, frontend-developer, tdd-specialist, devops-engineer, and more.

  2. Important: @webdevtoday/claude-agents is archived

    main

    ⚠️ Project Status: Archived

    @webdevtoday/claude-agents is no longer maintained as of June 2026.

    This project was created to manage sub-agents and hooks before Claude Code provided native support. Since Claude Code now includes these features natively, this framework is no longer necessary.

    Recommended Native Alternatives:

    • Subagents: Specialized workers with their own context (auto-delegated by description).
    • Skills: Reusable workflows/knowledge invoked with /name (replaces custom slash commands).
    • Hooks: Event-driven automation.
    • Plugins + Marketplaces: The modern way to package agents, skills, and MCP.
    • Memory: Use CLAUDE.md and native auto-memory instead of the simulated in-process memory store.

    The following documentation is preserved for historical reference only.

  3. Execute Agents Concurrently for Maximum Performance

    main

    To achieve 2-4x performance improvements, avoid running agents sequentially. Instead, batch related operations into a single request by explicitly asking Claude Code to run them concurrently.

    Example of a fast concurrent request:

    > Please run these concurrently:
> - /review
> - /test
> - /document

  4. Memory integration for prime-context

    main

    The prime-context command uses a memory system to store findings, allowing subsequent agents to coordinate based on the project state.

    For Context-Forge projects, the following keys are set:

    • context:type: set to 'context-forge'
    • context:stage: the current implementation stage
    • context:prps: the list of available PRPs

    For Standard projects, the following keys are set:

    • context:type: set to 'standard'
    • context:structure: the detected project structure
    • context:needs: a list of requirements (e.g., ['planning', 'documentation'])
    // For context-forge projects
memory.set('context:type', 'context-forge');
memory.set('context:stage', currentStage);
memory.set('context:prps', availablePRPs);

// For standard projects  
memory.set('context:type', 'standard');
memory.set('context:structure', projectStructure);
memory.set('context:needs', ['planning', 'documentation']);

  5. How the Agent Chaining System works

    main

    The claude-agents chaining system allows multiple agents to work in sequence or parallel to complete complex workflows. Instead of passing massive amounts of text, agents communicate through a Memory-Based Handoff system.

    Core Principles:

    • Memory-Based Handoffs: Agents communicate by writing to and reading from a shared memory system.
    • Lightweight Data: Only essential data is passed between agents to prevent context window bloat.
    • Type Matching: The system matches an agent's output type (e.g., technical-plan) to the next agent's required input type.
    • Context Preservation: Each agent runs in isolation, keeping the orchestrator's context clean.

  6. Use the Hooks system for automated workflows

    main

    The hooks system allows agents to trigger automated actions based on specific events in the development lifecycle. Hooks can be defined to run commands or notify users.

    Available Hook Types

    Hook TypeDescriptionTrigger
    PostToolUse:EditAfter file editsAny file modification
    PostToolUse:WriteAfter file creationNew file written
    PostToolUse:BashAfter command executionBash commands run
    PreToolUseBefore any tool useTool about to run
    TaskCompleteAfter task completionAgent finishes task
    StopOn conversation endSession terminating

    Hook Configuration Examples

    Auto-Review Hook

    Triggers a message when .js, .ts, or .py files are edited:

    {
  "hooks": {
    "PostToolUse:Edit": [{
      "matcher": "\\.(js|ts|py)$",
      "hooks": [{
        "type": "command",
        "command": "echo 'Consider running /review' >&2"
      }]
    }]
  }
}

    Test Runner Hook

    Automatically runs npm test when files in the src/ directory are modified:

    {
  "PostToolUse:Edit": {
    "condition": "file.includes('src/')",
    "commands": ["npm test -- --watch=false"]
  }
}

  7. Use memory coordination for multi-agent workflows

    main

    Agents can share information across workflows using a memory coordination pattern. This allows one agent to store findings that another agent can later retrieve.

    • Storing data: Use memory.set(key, value) within the agent's logic or instructions.
    • Retrieving data: Use memory.get(key) to access stored information.

    Recommended Patterns:

    • Store discoveries: memory.set('agent:findings', data)
    • Share with others: memory.set('shared:resource', info)
    • Read from others: memory.get('other-agent:data')
    // Store discoveries for other agents
memory.set('analysis:key-findings', findings);
memory.set('analysis:data-summary', summary);
memory.set('analysis:visualizations', charts);

  9. Understand the structure of a Claude Sub-Agent

    main

    A Claude Sub-Agent is a specialized AI assistant composed of three main files located within its own directory under the agents/ folder:

    • agent.md: The core definition containing the system prompt, capabilities, and activation triggers.
    • metadata.json: Configuration and metadata (version, author, tags, tools, etc.).
    • hooks.json (Optional): Automation hooks for triggering specific actions based on events like tool use or task completion.
    agents/
└── your-agent/
    ├── agent.md       # Core agent definition and prompt
    ├── metadata.json  # Agent configuration and metadata
    └── hooks.json     # Optional automation hooks

  10. Use Memory Coordination between Agents

    main

    Agents share discoveries through a shared memory system. One agent can store data (e.g., discovered API endpoints), and subsequent agents can retrieve and act upon that data. This allows for a coordinated, multi-agent workflow where specialists build on each other's findings.

    // Agents store discoveries
memory.set('api:endpoints:discovered', {
  users: '/api/users',
  products: '/api/products'
});

// Other agents retrieve and use
const endpoints = memory.get('api:endpoints:discovered');

  11. Understand agent installation scopes

    main

    Agents can be installed in two different scopes depending on their intended usage:

    1. User Scope (~/.claude/agents/): These agents are available globally across all your projects. This is the default location for personal agents.
    2. Project Scope (.claude/agents/): These agents are specific to a single project. This is ideal for team-shared agents that can be managed via version control. Use the --project flag to interact with project-scoped agents.

  12. Validation Gates in PRP Execution

    main

    PRP execution uses a tiered validation system to ensure each implementation step meets quality standards. You must define the specific commands for each level within your PRP file.

    LevelTypeDescription
    Level 1Syntax & StyleLinting and formatting checks. Fix issues before proceeding.
    Level 2Unit TestsExecution of unit tests. All tests must pass.
    Level 3Integration TestsExecution of integration tests to verify end-to-end functionality.
    Level 4Deployment/AdvancedFinal validation or advanced deployment checks.

    If any validation gate fails, you must use an appropriate agent (like debugger) to fix the issue and re-run the validation before moving to the next step.