convez.ai
AgenteAutomaçãoAvançado
jayfoeelite

Custom Agents Orchestrator

jayfoeelite/custom-agents-orchestrator

Orquestrador de 46 agentes IA para projetos complexos com verificação triangulada

Ver no GitHub
InicialPluginScore · de 0 a 100

Sistema sofisticado de orquestração de agentes IA implementando a metodologia SPARC com 46 agentes especializados coordenados para design, implementação e validação de projetos complexos. Utiliza Triangulação Cognitiva e avaliação RULER para garantir alinhamento com a intenção do usuário em cada fase do workflow.

Instalação

$npx convez-ai jayfoeelite/custom-agents-orchestrator

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 11 meses
Versão
—
Issues abertas
1
Contribuidores
0

Casos de uso

  • Desenvolvimento de sistemas de software com requisitos complexos e multidisciplinares
  • Implementação TDD com validação de qualidade automatizada em cada fase
  • Verificação de alinhamento entre intenção do usuário e implementação final
  • Geração de múltiplas trajetórias de implementação com ranking comparativo
  • Auditorias de segurança e concorrência em arquiteturas distribuídas

Veredito

Projeto ambicioso e bem-estruturado que implementa metodologia rigorosa (SPARC) com múltiplos agentes especializados. Ideal para equipes que precisam de orquestração completa de desenvolvimento, mas exige curva de aprendizado significativa e integração cuidadosa com fluxos existentes.

README

A tradução para o português deste README ainda está na fila.

Custom Agents Orchestrator

A sophisticated AI Agent Orchestration System implementing the SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology with advanced Cognitive Triangulation, RULER-based quality evaluation, and specialized domain agents.

🌟 Overview

This project coordinates multiple specialized AI agents to collaboratively design, implement, test, and validate complex software projects through a structured, verifiable workflow that ensures alignment with user intent at every stage.

✨ Key Features

🏗️ SPARC Methodology Framework

  • Specification Phase: Comprehensive requirements gathering and acceptance criteria
  • Pseudocode Phase: Language-agnostic logical blueprints
  • Architecture Phase: High-level system design with resilience patterns
  • Refinement Phase: Iterative TDD implementation with quality gates
  • Completion Phase: Documentation, maintenance, and final verification

🔀 Cognitive Triangulation

Multi-stage verification ensuring alignment between:

  • User's Core Intent → User Stories → Specifications → Pseudocode → Architecture → Implementation → Tests
  • Enforced by the Devil's Advocate agent at critical checkpoints
  • Prevents requirement drift and ensures implementation fidelity

📊 RULER Quality Evaluation

  • LLM-as-Judge methodology for comparative quality assessment
  • Generates multiple implementation trajectories
  • Ranks solutions based on efficiency, clarity, and maintainability
  • Ensures optimal implementation selection

🤖 46 Specialized Agent Modes

Orchestrators (11 agents)

  • uber-orchestrator: Master conductor managing overall project flow
  • orchestrator-goal-clarification: Intent validation and synthesis
  • orchestrator-sparc-*-phase: Phase-specific coordinators (Specification, Pseudocode, Architecture)
  • orchestrator-sparc-refinement-*: Testing and implementation managers
  • orchestrator-sparc-completion-*: Documentation and maintenance coordinators
  • orchestrator-simulation-synthesis: Multi-method verification orchestrator
  • orchestrator-state-scribe: Intelligent state interpreter and recorder

Workers (9 agents)

  • spec-writer-comprehensive: Modular specification creation
  • spec-writer-from-examples: User story extraction from examples
  • pseudocode-writer: Detailed logic blueprints
  • coder-test-driven: TDD implementation specialist
  • coder-framework-boilerplate: Project scaffolding generator
  • tester-tdd-master: Test implementation expert
  • tester-acceptance-plan-writer: High-level test strategy
  • docs-writer-feature: Feature documentation specialist
  • research-planner-strategic: Adaptive multi-arc research strategist

Validators & Auditors (5 agents)

  • devils-advocate-critical-evaluator: Cognitive Triangulation enforcer
  • auditor-concurrency-safety: Race condition detector
  • auditor-financial-logic: Capital & risk validator
  • validator-api-integration: External dependency verifier
  • validator-performance-constraint: Sub-100ms latency enforcer

Quality & Analysis (4 agents)

  • ruler-quality-evaluator: LLM-as-judge quality arbiter
  • bmo-system-model-synthesizer: As-built system documentation
  • bmo-holistic-intent-verifier: Final triangulation verifier
  • optimizer-module: Code quality and performance enhancement

Domain Specialists (17 agents)

Financial trading and specialized vertical agents including performance fee calculators, client portal generators, audit trail recorders, and more.

🚀 Getting Started

Prerequisites

  • Python 3.7+ (for validation tooling)
  • Git
  • RooCode or compatible AI coding assistant

Installation

  1. Clone the repository:
git clone https://github.com/YOUR_USERNAME/custom-agents-orchestrator.git
cd custom-agents-orchestrator
  1. Install Python dependencies for tooling:
pip install -r tools/requirements.txt
  1. (Optional) Validate agent definitions:
python tools/validate-agents.py

📁 Project Structure

custom-agents-orchestrator/
├── agents/                    # 46 agent YAML definitions
├── docs/                      # Documentation
│   ├── research/             # Research findings and decisions
│   ├── TUTORIAL.md          # Interactive tutorial
│   ├── UBER_ORCHESTRATOR_MODE_DELEGATION_GUIDE.md
│   └── project_plan.md      # Implementation roadmap
├── memory-bank/              # Project context and state
│   ├── productContext.md
│   ├── activeContext.md
│   ├── systemPatterns.md
│   ├── decisionLog.md
│   └── progress.md
├── schemas/                  # JSON Schema for validation
│   └── agent-mode-schema.json
├── tools/                    # Validation and analysis tools
│   ├── validate-agents.py
│   ├── generate-dependency-graph.py
│   └── merge-agents.py
├── SETUP_GUIDE.md           # Detailed setup instructions
└── validation_report.md     # Agent validation results

🛠️ Usage

Working with Agent Modes

All 46 agent modes are defined in the agents/ directory as YAML files. Each agent has:

  • Unique slug identifier
  • Role definition
  • Custom instructions
  • Group permissions
  • Communication protocols

Validation Tools

Validate all agents:

python tools/validate-agents.py

Generate dependency graph:

python tools/generate-dependency-graph.py

Merge agents for RooCode:

python tools/merge-agents.py

Agent Communication Protocol

All agents use standardized routing headers:

To: [recipient-agent-slug]
From: [sender-agent-slug]

📚 Documentation

🔄 Workflow

  1. Goal Clarification: uber-orchestrator → orchestrator-goal-clarification
  2. Research & Planning: → research-planner-strategic
  3. Triangulation Check #0: → devils-advocate-critical-evaluator
  4. Specification Phase: → orchestrator-sparc-specification-phase
  5. Pseudocode Phase: → orchestrator-sparc-pseudocode-phase
  6. Architecture Phase: → orchestrator-sparc-architecture-phase
  7. Refinement Loop (per feature):
    • orchestrator-sparc-refinement-testing
    • orchestrator-sparc-refinement-implementation
  8. Ultimate Triangulation Audit:
    • bmo-system-model-synthesizer
    • bmo-holistic-intent-verifier
  9. Final Verification: → orchestrator-simulation-synthesis

🧪 Testing Strategy

  • State-Based Classical TDD: Focus on observable outcomes
  • Multi-Methodology: Unit, Integration, Property-Based, Chaos, Metamorphic
  • No Mock Internal Collaborators: Maximize refactoring flexibility
  • Comprehensive Coverage: Edge cases, error scenarios, performance constraints

🤝 Contributing

  1. Fork the repository
  2. Create a feature branch (git checkout -b feature/amazing-feature)
  3. Validate your changes (python tools/validate-agents.py)
  4. Commit your changes (git commit -m 'Add amazing feature')
  5. Push to the branch (git push origin feature/amazing-feature)
  6. Open a Pull Request

📊 Project Status

  • ✅ Phase 1: Agent Definition & Validation (Complete)
  • ✅ Validation Tooling (Complete)
  • ✅ Documentation & Tutorial (Complete)
  • ✅ RooCode Integration (Complete)
  • 🔄 Phase 2: Full Automation via Anthropic API (In Planning)

See V2_IMPLEMENTATION_STATUS.md for detailed progress.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

  • Built on the SPARC methodology
  • Implements Cognitive Triangulation principles
  • Uses RULER (LLM-as-Judge) quality evaluation
  • Powered by RooCode AI coding assistant

📧 Contact

For questions, issues, or contributions, please open an issue on GitHub.


Note: This is an intelligent orchestration system for AI-assisted software development. It requires understanding of AI agent workflows and the SPARC methodology for effective use.

Ver o original no GitHub

Bom para

Relacionados