Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Agent Fleet: AI Dev Team

    1

    A complete multi-agent software development lifecycle for building scalable, documented, and architecturally sound products.

    Free

    Security scanned
    Agent Fleet: AI Dev Team

    Agent Fleet: AI Dev Team

    Example session with this skill installed

    Run the foundation phase for a new project called 'TaskTracker' based on the attached client brief and transcript.

    • Read your context and instructions
    • Compiled the agent fleet

    I have initiated Phase A (Foundation) for the TaskTracker project. I have processed the client brief and transcript to establish the core requirements and initial module mapping.

    Foundation Phase A: Initial Artifacts

    PhaseAgentDeliverableStatus
    F.0product-ownerdocs/00-global/requirements.mdCOMPLETED
    F.1product-ownerdocs/00-global/module-map.mdCOMPLETED
    F.2system-architectdocs/00-global/architecture.mdPENDING
    F.3ux-engineerdocs/00-global/design-system.mdPENDING

    Module Build Queue

    OrderModuleDescriptionDependency
    1auth-systemUser registration, login, and JWT managementNone
    2task-engineCore CRUD for tasks and categoriesauth-system
    3notification-serviceEmail and push alerts for task deadlinestask-engine
    4analytics-dashboardUser productivity reportingtask-engine

    Next steps

    1. Review the generated docs/00-global/requirements.md for accuracy.
    2. Approve the module-map.md build order.
    3. Run agent-fleet-foundation again to proceed with Service Design (F.2).

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Building software in a multi-agent environment often leads to duplicated components, divergent API contracts, and fragmented documentation. The agent-fleet package provides a structured, multi-phase lifecycle for transforming client briefs into shipped software using a team of specialized agent roles.

    What it does

    • Foundation phase execution establishes project skeletons, global architecture, design systems, and shared data schemas before coding begins.
    • Module loop orchestration manages the lifecycle of individual features from business requirements (BRD) to QA and closure.
    • Parallel development synchronization uses frozen API contracts to allow frontend and backend agents to build, mock, and test in isolation.
    • Inventory management tracks reusable components and services, preventing architectural drift and redundant implementations.
    • Automated QA lifecycle generates test cases from requirements and executes black-box verification against running applications.

    How it works

    1. Phase A (Foundation): Run requirements-intake and module-decomposition to define the project scope and build order.
    2. Phase B (Module Loop): Execute write-brd followed by groom-module for the next item in the module map.
    3. Execution: Use api-contract to freeze the interface, then run frontend, backend, and QA tasks in parallel.
    4. Integration: Run swap-mocks and e2e-verify to ensure the module meets acceptance criteria.
    5. Closure: Run close-module to update the global inventory and changelog.

    Frameworks & tools

    This package is stack-agnostic and relies on a CONVENTIONS.md file to define specific technologies. It manages artifacts via Markdown templates and integrates with tools capable of launching subagents using specialized role definitions.

    Why this beats prompting it yourself

    Standard prompting often results in "one-shot" code that ignores global project state. This skill enforces a rigid phase-gate process where every agent must read the global inventory and adhere to frozen contracts, ensuring serial deliveries accumulate into a cohesive product rather than a collection of scripts.

    Use cases

    • Orchestrating a team of specialized agents to build a full-stack application.
    • Maintaining architectural consistency across a large, multi-module project.
    • Generating comprehensive technical documentation and test suites automatically.
    • Scaling development by allowing parallel frontend and backend work without interface mismatch.

    Known limitations

    Requires a structured directory tree and specific templates to function. Initial setup of the foundation phase is mandatory before module-level work can begin.

    Open source, also available as a Claude Code plugin: github.com/ahsuniqbal/agent-fleet

    Requires pre-existing directory structure and templates. Phase A must be completed before starting Phase B modules. Logic depends on subagent orchestration capabilities.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 4 days ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Browser
    Network Access
    Read Files
    Write Files
    Listed4 days ago

    What's inside

    Frequently Asked Questions

    agent-fleet solves "architectural drift" and "hallucinated APIs" by enforcing a phase-gate process where all agents must adhere to frozen contracts and a global component inventory, ensuring that complex projects stay cohesive as they grow.

    The skill is stack-agnostic and works with any LLM or agent framework capable of executing sub-tasks; it uses a `CONVENTIONS.md` file to define your specific technology choices (e.g., React, Python, PostgreSQL) for the agents to follow.

    Setup begins with a Foundation Phase where you run intake and decomposition commands to establish a project skeleton; note that you must complete this initial architectural setup before the agents can begin working on individual modules.

    The package includes the full multi-phase orchestration logic, specialized agent role definitions, Markdown templates for all lifecycle artifacts (BRDs, API contracts, etc.), and the automation scripts for the module loop.

    Unlike simple prompts, this skill uses "Parallel development synchronization" which allows your frontend and backend agents to work simultaneously against a shared, mocked API contract, significantly reducing total delivery time.

    New in Agents & Orchestration