AI Coding Tools Orchestrator and Agentic Team Runtime
Six independent systems — an AI Orchestrator, an Agentic Team runtime, AI Collaboration task continuity, an MCP Server, a Context Dashboard, and Graphify (project-to-graph intelligence engine) — that help Claude, Codex, Cursor, Gemini, Copilot, Ollama, and llama.cpp collaborate on software development tasks.
🪈 Intelligent orchestration system that coordinates multiple AI coding assistants (Claude, Codex, Gemini CLI, Copilot CLI) to collaborate on complex software development tasks via REPL or a Vue/Nuxt UI dashboard. Also includes an Agentic Team runtime with role-based multi-agent open communication & lead-gated final responses.
AI Coding Tools ships six independent systems in a single repository:
The Orchestrator runs step-based workflows where AI agents execute tasks in sequence (implement, review, refine).
The Agentic Team runs a free-communication runtime where role-based agents (Project Manager, Architect, Developer, QA, DevOps) discuss a task in turns until the team lead declares the work complete.
Graphify turns any project directory into a queryable knowledge graph — classes, functions, imports, call graphs, and design rationale stored in a local SQLite database with FTS5 search.
AI Collaboration is a separately installable, zero-dependency task-continuity plugin for Claude Code, Codex, Cursor, Gemini CLI, and GitHub Copilot CLI. Native lifecycle hooks capture prompts, tool activity, Git state, tests, and checkpoints into a private local store; portable skills and a standalone MCP server let the next agent resume with focused, deterministic context.
The MCP Server bridges both engines to IDE-based AI assistants.
The Context Dashboard visualizes the graph memory. Each runtime carries its own adapters, configuration, UI, and CLI; AI Collaboration is also standalone and imports from neither runtime.
Beyond the core engines, we provide a complete Agentic Infrastructure that empowers AI agents:
9 Specialized Agents for web, backend, security, DevOps, AI/ML, database, mobile, performance, and documentation
22 Reusable Skills across development, testing, security, DevOps, AI/ML, and documentation
34+ MCP Tools for code analysis, security scanning, testing, DevOps, and context memory
Graph Context System with hybrid search (BM25 + semantic) for persistent memory and learning
Domain Rules encoding best practices for security, database, API design, performance, and AI/ML
[!TIP]
Quickstart with the Orchestrator for structured workflows, or the Agentic Team for open-ended collaboration. Both systems benefit from the shared agentic infrastructure and context memory. See QUICKSTART.md for quick setup instructions to get started in ~2 minutes. Or, see #quick-start below for a detailed walkthrough.
[!TIP]
Do not want to set up the full platform? Install only AI-Collaboration-Skills/. It needs no project Python dependencies, web UI, orchestrator configuration, or hosted service—just Python 3.8+, Git, and a supported coding agent. Use it to move an in-progress task between agents, recover work after a context limit, or keep a durable local audit trail while continuing to work directly in your preferred CLI or editor.
Agentic Infrastructure
We provide a rich agentic infrastructure that both the Orchestrator and Agentic Team utilize to empower their AI agents with specialized knowledge, reusable skills, powerful tools, and persistent context memory. This infrastructure is designed to be modular and extensible, allowing for easy addition of new agents, skills, tools, and context nodes as the system evolves.
graph TB
subgraph "🧠 Agentic Infrastructure"
direction LR
subgraph AGENTS["Specialized Agents (9)"]
WEB[Web Frontend]
API[Backend API]
SEC[Security]
OPS[DevOps]
ML[AI/ML]
DB[Database]
end
subgraph SKILLS["Skills Library (22)"]
DEV[Development]
TEST[Testing]
SECS[Security]
DEVOPS[DevOps]
AIML[AI/ML]
DOCS[Documentation]
end
subgraph TOOLS["MCP Tools (34+)"]
CODE[Code Analysis]
SCAN[Security Scan]
TTOOLS[Testing]
DTOOLS[DevOps]
CTX[Context Memory]
end
subgraph CONTEXT["Graph Context"]
GRAPH[(Graph Store)]
SEARCH[Hybrid Search]
EMBED[Embeddings]
end
end
AGENTS --> SKILLS
SKILLS --> TOOLS
TOOLS --> CONTEXT
Both the Orchestrator and Agentic Team maintain independent graph-based context databases for persistent memory and cross-session learning. A unified Context Dashboard aggregates both stores for visualization.
Hybrid Search combines three retrieval strategies via Reciprocal Rank Fusion (RRF):
BM25 — Keyword-based search using term frequency–inverse document frequency
Semantic — Embedding-based similarity using vector cosine distance
Hybrid — Fused ranking of BM25 + semantic results using RRF for best-of-both-worlds retrieval
Project-Scoped Context Graphs
Both systems support project-scoped context graphs for full portability. When a user points the system at their project directory, agents automatically scan and build a rich context graph of the codebase.
Portability: Set PROJECT_PATH environment variable or settings.project_path in config YAML — the system handles the rest
Incremental updates: rescan_project() rebuilds the graph atomically; delete_project_graph() cleanly removes all project nodes
[!TIP]
Auto-seeding: Run scripts/seed_context_graphs.py to populate both context databases with generic reference knowledge (patterns, mistakes, decisions) on first use. Seed data contains no hallucination-prone fake tasks or conversations — only universally applicable best practices.
[!NOTE]
Context Dashboard: Launch with python -m context_dashboard (port 5003) to visualize both context graphs, inspect nodes/edges, and search across all stored knowledge. See context_dashboard/README.md for details.
[!TIP]
Obsidian Export: Export any graph as an Obsidian vault for offline interactive exploration. Graphify: graphify export obsidian <path>. Context systems: ContextExporter.export_obsidian(). Each vault includes [[wikilinks]], typed folders, YAML frontmatter, and pre-configured .obsidian/graph.json color groups. See GRAPHIFY.md, ORCHESTRATOR.md, and AGENTIC_TEAM.md.
Skills Library & Agent Definitions
AI coding agents are enhanced with specialized role definitions, reusable skills, and domain rules that are automatically loaded based on context.
graph LR
subgraph "Agent Ecosystem"
direction TB
subgraph CLAUDE[".claude/"]
CA["agents/ (11)"]
CS["skills/ (23)"]
CR["rules/ (11)"]
CC[CLAUDE.md]
end
subgraph CODEX[".codex/"]
XA["agents/ (13)"]
XC[config.toml]
XR[rules/]
end
AGENTS_MD[AGENTS.md — Shared instructions]
end
CA --> CS
CA --> CR
AGENTS_MD --> CLAUDE
AGENTS_MD --> CODEX
style CLAUDE fill:#7c3aed,color:#fff
style CODEX fill:#059669,color:#fff
Claude Agents — 11 specialized agents in .claude/agents/:
Agent
File
Domain
Web Frontend
web-frontend.md
React, Vue, CSS, accessibility, responsive design
Backend API
backend-api.md
REST, GraphQL, databases, Flask/FastAPI
Security Specialist
security-specialist.md
OWASP, vulnerability analysis, secure coding
DevOps Infrastructure
devops-infrastructure.md
Docker, Kubernetes, CI/CD, cloud
AI/ML Engineer
ai-ml-engineer.md
ML pipelines, embeddings, LLM integration
Database Architect
database-architect.md
Schema design, query optimization, migrations
Mobile Developer
mobile-developer.md
iOS, Android, React Native, Flutter
Performance Engineer
performance-engineer.md
Profiling, load testing, optimization
Documentation Writer
documentation-writer.md
API docs, architecture, tutorials
Code Reviewer
code-reviewer.md
Code quality, best practices, PR reviews
Test Runner
test-runner.md
Test execution, coverage, failure diagnosis
Codex Agents — 13 specialized agents in .codex/agents/:
Agent
File
Domain
Code Reviewer
code-reviewer.toml
Code quality and review automation
Explorer
explorer.toml
Codebase exploration and research
Security Specialist
security-specialist.toml
Security auditing and vulnerability scanning
Web Frontend
web-frontend.toml
Frontend development and UI patterns
DevOps Infrastructure
devops-infrastructure.toml
Infrastructure and deployment automation
Implementer
implementer.toml
Feature implementation and coding
Database Architect
database-architect.toml
Database design and optimization
Performance Engineer
performance-engineer.toml
Performance profiling and optimization
Test Runner
test-runner.toml
Test suite execution and diagnosis
AI/ML Engineer
ai-ml-engineer.toml
ML pipelines and AI system design
Backend API
backend-api.toml
Backend services and API development
Documentation Writer
documentation-writer.toml
Technical documentation
Mobile Developer
mobile-developer.toml
Mobile application development
Skills Library — 24 reusable skill templates in .claude/skills/ across 7 categories:
Four additional standalone skills (context-graph-builder, generate-reports, health-check, run-tests) provide operational task automation.
Domain Rules — 11 rule files in .claude/rules/ encoding best practices:
Rule
File
Enforces
Adapters
adapters.md
Adapter pattern, base class contracts
API Design
api-design.md
RESTful conventions, versioning, error formats
Testing
testing.md
Pytest patterns, coverage requirements, fixtures
Performance
performance.md
Profiling, caching, async patterns
Config
config.md
YAML config, environment variables, validation
AI/ML
ai-ml.md
Model integration, embeddings, prompt patterns
Observability
observability.md
Logging, metrics, health checks
Frontend
frontend.md
Component patterns, accessibility, state management
CI/CD
ci-cd.md
Pipeline design, deployment gates, rollback
Security
security.md
Input validation, auth, secrets management
Database
database.md
Schema design, migrations, query safety
[!NOTE]
Agents automatically inherit access to all skills and rules in their scope. When Claude Code is invoked with a specialized agent (e.g., @security-specialist), it loads the agent definition, relevant skills, and applicable domain rules to provide expert-level guidance.
Configuration Files
File
Purpose
.claude/CLAUDE.md
Main instructions for Claude Code — imports AGENTS.md and sets project context
.claude/settings.json
Claude project settings (permissions, model preferences)
.codex/config.toml
Codex project configuration
.codex/agents/*.toml
Codex agent role definitions with system prompts
AGENTS.md
Shared instructions read by all AI coding agents (Codex, Gemini CLI, etc.)
The diagram shows co-location, not a runtime dependency: AI Collaboration observes supported agent hosts directly and writes only to its own local store. It does not call into the Orchestrator or Agentic Team, and neither execution runtime needs the plugin installed.
Orchestrator Workflow Execution
The Orchestrator processes tasks through a configurable pipeline of AI agents. Each step in a workflow maps to a specific agent and role.
sequenceDiagram
participant User
participant CLI as CLI / Web UI
participant Engine as Core Engine
participant WF as Workflow Manager
participant Codex as Codex Adapter
participant Gemini as Gemini Adapter
participant Claude as Claude Adapter
participant FB as Fallback Manager
User->>CLI: Submit task
CLI->>Engine: execute(task, workflow="default")
Engine->>WF: load workflow steps
WF->>Codex: Step 1 -- implement
alt Codex unavailable
Codex-->>FB: error
FB->>FB: route to local-code
end
Codex-->>WF: implementation
WF->>Gemini: Step 2 -- review
Gemini-->>WF: review feedback
WF->>Claude: Step 3 -- refine
Claude-->>WF: refined code
WF-->>Engine: final result
Engine-->>CLI: display output
CLI-->>User: code + report
Agentic Team Communication Flow
The Agentic Team uses free role-to-role communication. Agents speak in turns, address each other by role, and the team lead decides when the task is complete.
sequenceDiagram
participant User
participant PM as Project Manager (Lead)
participant Arch as Software Architect
participant Dev as Software Developer
participant QA as QA Engineer
participant DevOps as DevOps Engineer
User->>PM: "Build a REST API with auth"
PM->>Arch: Define architecture and constraints
Arch->>Dev: Provide interface specs
Dev->>Dev: Implement code
Dev->>QA: Request quality review
QA->>Dev: Report edge cases
Dev->>Dev: Fix issues
Dev->>DevOps: Request deployment review
DevOps->>PM: Confirm operational readiness
PM->>User: Final consolidated response
Adapter Resolution Flow
Both systems resolve which AI backend to use at runtime. The adapter layer abstracts cloud CLIs and local model servers behind a common interface.
flowchart TD
REQ[Incoming Task Step] --> CHECK{Agent Enabled?}
CHECK -->|Yes| HEALTH{Health Check}
CHECK -->|No| SKIP[Skip Agent]
HEALTH -->|Healthy| EXEC[Execute via Adapter]
HEALTH -->|Unhealthy| FB{Fallback Configured?}
FB -->|Yes| LOCAL[Route to Local Adapter<br/>Ollama / llama.cpp]
FB -->|No| ERR[Raise AgentUnavailableError]
EXEC --> PARSE[Parse CLI Output]
LOCAL --> PARSE
PARSE --> RESULT[Return AgentResponse]
style EXEC fill:#2b6cb0,stroke:#2c5282,color:#fff
style LOCAL fill:#276749,stroke:#22543d,color:#fff
style ERR fill:#9b2c2c,stroke:#742a2a,color:#fff
Local model execution semantics and limitation
Local models are deeply integrated for routing, offline mode, and fallback, but they are not direct workspace editors in the current implementation.
Path
How it runs
Direct file edits
Cloud CLI adapters (Codex/Claude/Gemini/Copilot)
CLI process + workspace execution path
Yes (tool-dependent)
Local adapters (Ollama/llama.cpp/OpenAI-compatible)
HTTP prompt-completion (/api/generate or /v1/completions)
No (text output only)
Best use for local models: offline drafting, review feedback, and cloud-to-local fallback continuity.
[!CAUTION]
While it is possible to make local LLMs directly edit files (e.g., via a file-editor tool), this approach is currently disabled to prevent unintended destructive changes. Local adapters are advisory — they provide text output that the Orchestrator can use to inform the next steps, but they do not have direct write access to the workspace. This design choice prioritizes safety and predictability while still leveraging local models for their strengths in drafting and feedback. The hard part is not feasibility, it’s safety and reliability: permissions, diff constraints, validation/tests before write, rollback, and preventing bad edits.
Dedicated REPL (agentic-shell) with --max-turns and --offline flags
Web UI
Dedicated Nuxt 3 + Flask UI with Config Studio, real-time turn streaming, team communication view
Local model behavior
Local adapters contribute role outputs and fallback text, but do not directly write files
Fallback
Independent fallback manager and offline detector
Configuration
Separate agents.yaml with agentic_team.roles section for role-to-agent mapping
AI Collaboration (AI-Collaboration-Skills/)
AI Collaboration is for developers who already work inside one or more coding agents and want continuity without adopting a new orchestration runtime. It can capture work passively during ordinary agent sessions, then expose only the relevant history when another agent resumes the task.
Category
Features
Continuity
Tasks, provider sessions, normalized events, checkpoints, test history, and live Git state
Hosts
Claude Code, Codex, Cursor, Gemini CLI, and GitHub Copilot CLI
Portable layer
Agent Plugins 1.0 manifest, five Agent Skills, and ten MCP tools
Passive capture
Host-native lifecycle hooks with fail-open behavior and no model invocation
Storage
Private local SQLite store plus SHA-256 content-addressed gzip objects
Privacy
Recursive credential redaction, payload size bounds, no network service
Boundary
Zero imports from orchestrator/, agentic_team/, or the root MCP server
Typical uses include:
hand off implementation from Claude Code to Codex for debugging, then to Cursor for UI work;
recover the current task, changed files, last checkpoint, and failing tests after a context-window reset;
search prior tool activity without injecting an entire transcript into the next model context;
create deliberate checkpoints before switching agents, machines, or work sessions;
retain a private, inspectable local event history with no hosted synchronization service.
Path traversal protection, input sanitization, bounded parameters, no debug mode
Quick Start
Use AI Collaboration Only (Minimal Setup)
If you want cross-agent continuity rather than a complete orchestration platform, use the standalone plugin directly. It has no dependency on the root requirements.txt.
git clone https://github.com/hoangsonww/AI-Agents-Orchestrator.git
cd AI-Agents-Orchestrator
# Example: install into Codex from the local plugin marketplace
codex plugin marketplace add ./AI-Collaboration-Skills
codex plugin add ai-collaboration@ai-collaboration
# Start a continuity task from the repository you are editing
cd /path/to/your-project
/path/to/AI-Agents-Orchestrator/AI-Collaboration-Skills/bin/ai-collaboration \
task start "Implement account recovery"
The plugin begins recording supported lifecycle events locally. Open another supported agent in the same repository and invoke the resume-task skill or call ai_collaboration.get_context; both agents resolve the same active task from ~/.ai-collaboration/.
Operating System: Linux, macOS, or Windows (WSL recommended)
Python: 3.8 or higher
Node.js: 20+ (for Web UI)
Memory: Minimum 4GB RAM
Disk Space: 1GB for installation + workspace
Network: Required for AI CLI tools and updates
Claude Code: Installed, setup, and signed in on your machine (Required for any workflows using Claude Code - if you run claude in terminal and it works, you're good)
OpenAI Codex: Installed and authenticated (if using Codex agent, try running codex and see if it responds)
Google Gemini CLI: Installed and authenticated (if using Gemini agent, try gemini --version to verify)
GitHub Copilot CLI: Installed and authenticated (if using Copilot agent, try copilot --version to verify)
Llama.cpp or Ollama: If using local LLM agents, ensure they are installed and configured properly (try running ollama list or llamacpp --help to verify)
Optional: Docker and Docker Compose for containerized setup
# Interactive shell
./ai-orchestrator shell
# One-shot task
./ai-orchestrator run "Create a Python REST API" --workflow default
# Start the Web UI
make run-ui
# Then open http://localhost:5001
Run the Agentic Team
# Interactive REPL
./ai-orchestrator agentic-shell
# With options
./ai-orchestrator agentic-shell --max-turns 16 --offline
# Start the Web UI
make run-agentic-ui
# Then open http://localhost:5002
Verify Installation
./ai-orchestrator --help # Show all commands
./ai-orchestrator agents # List available agents
./ai-orchestrator workflows # List available workflows
./ai-orchestrator validate # Validate configuration
[!IMPORTANT]
Key design decision:orchestrator/ and agentic_team/ are fully self-contained. Each carries its own adapters/, config/, and ui/ directories. There are no shared root-level adapters/, ui/, or config/ directories. The two systems share zero code and zero imports.
Configuration
Both systems read their configuration from their own orchestrator/config/agents.yaml file. The files follow the same schema but are independent.
graph LR
subgraph Orchestrator Config
OC["orchestrator/config/agents.yaml"]
OC --> OA["agents: codex, gemini, claude, ..."]
OC --> OW["workflows: default, quick, thorough, ..."]
OC --> OS["settings: max_iterations, output_dir, ..."]
OC --> OAT["agentic_team: roles (shared schema)"]
end
subgraph Agentic Team Config
AC["agentic_team/config/agents.yaml"]
AC --> AA["agents: codex, gemini, claude, ..."]
AC --> AW["workflows: (same schema)"]
AC --> AS["settings: (same schema)"]
AC --> AAT["agentic_team: lead_role, max_turns, roles"]
end
style OC fill:#2d3748,stroke:#4a5568,color:#e2e8f0
style AC fill:#22543d,stroke:#276749,color:#e2e8f0
Available Workflows
Workflow
Pipeline
Use Case
default
Codex --> Gemini --> Claude
Production-quality code with full review
quick
Codex only
Fast prototyping
thorough
Codex --> Copilot --> Gemini --> Claude --> Gemini
Mission-critical code
review-only
Gemini --> Claude
Analyzing existing code
document
Claude --> Gemini
Documentation generation
offline-default
local-code --> local-instruct
Local-only, no cloud dependency
hybrid
local-code --> Claude (fallback: local-instruct)
Local drafts with cloud review
Deployment
Docker Compose (Recommended)
Both systems are packaged in a single multi-stage Docker image. The docker-compose.yml runs each as a separate service.
See DEPLOYMENT.md for systemd, Azure, load balancer, and production hardening guides.
Testing
The unified test suite (386 tests across 60+ modules) covers both systems independently.
flowchart LR
subgraph "make all"
FMT[format<br/>black + isort] --> LINT[lint<br/>flake8 + pylint]
LINT --> TYPE[type-check<br/>mypy]
TYPE --> TEST[test<br/>314 tests]
TEST --> SEC[security<br/>bandit + safety]
end
subgraph "Test Targets"
TEST --> T_ORCH[test-orchestrator]
TEST --> T_AGENT[test-agentic]
TEST --> T_UNIT[test-unit]
TEST --> T_INT[test-integration]
TEST --> T_E2E[test-e2e]
end
style FMT fill:#2b6cb0,stroke:#2c5282,color:#fff
style TEST fill:#276749,stroke:#22543d,color:#fff
style SEC fill:#9b2c2c,stroke:#742a2a,color:#fff
# Run all tests
make test
# Orchestrator tests only
make test-orchestrator
# Agentic team tests only
make test-agentic
# Unit tests only
make test-unit
# Integration tests only
make test-integration
# Tests with coverage report
make test-coverage
Code Quality
The codebase maintains a perfect 10.00/10 pylint score with zero warnings across the entire project, enforced by 15 pre-commit hooks (black, isort, flake8, mypy, bandit, pyupgrade, and more).
Metric
Value
Pylint Score
10.00 / 10
Warnings
0
Tests Passing
386
Pre-commit Hooks
15 / 15 passing
make lint # Lint all Python source (flake8 + pylint)
make format # Format with black + isort
make type-check # Run mypy on both subsystems
make security # Run bandit + safety
make all # Run everything (format, lint, type-check, test, security)
Monitoring
Prometheus metrics are exposed by the orchestrator UI backend on port 9090.
Metric
Description
orchestrator_tasks_total
Total tasks executed
orchestrator_task_duration_seconds
Task execution time
orchestrator_agent_calls_total
Agent invocations
orchestrator_agent_errors_total
Agent error count
orchestrator_cache_hits_total
Cache performance
Reports
The orchestrator automatically generates reports in reports/ when create_reports: true is set in agents.yaml. Reports include:
Interactive Chart.js dashboard with KPI cards, bar/line/doughnut charts
Reports are also generated programmatically via:
from orchestrator.observability import ReportGenerator
gen = ReportGenerator(reports_dir="./reports")
gen.seed_reports(config=config) # Generate all report types with sample data
API references, architecture deep-dives, testing guide, security
Screenshots
Some screenshots of the Web UIs and CLI interfaces:
MCP Server (Optional -- Model Context Protocol)
Both systems are optionally exposed via a FastMCP server (mcp_server/, port 8000), letting any MCP-compatible client (Claude Desktop, other LLM agents, or custom Python scripts) drive task execution programmatically.
# Start MCP server (stdio -- for Claude Desktop integration)
python -m mcp_server.server
# Start MCP server (HTTP -- for remote clients)
python -m mcp_server.server --transport http --port 8000
# Interactive REPL mode -- explore and test tools from the terminal
python -m mcp_server repl
# Launch the Context Dashboard (port 5003)
python -m context_dashboard
graph LR
subgraph "MCP Clients"
CD[Claude Desktop]
LA[LLM Agent]
PY[Python Client]
REPL[REPL Mode]
end
subgraph "MCP Server :8000 — 34+ Tools"
direction TB
CORE["Core (10)<br/>orchestrator_execute, agentic_team_execute,<br/>list_engines, health, config, validate"]
CODE["Code Analysis (4)<br/>code_complexity, find_patterns,<br/>analyze_deps, code_summary"]
SEC["Security (4)<br/>secrets_scan, security_headers_check,<br/>dependency_audit, injection_scan"]
TEST["Testing (4)<br/>suggest_tests, test_coverage_analysis,<br/>parse_tests, create_test_stub"]
DEVOPS["DevOps (5)<br/>dockerfile_analysis, compose_analysis,<br/>ci_config_check, deploy_checklist, env_config_analysis"]
CTX["Context (7)<br/>context_store_conversation, context_store_task,<br/>context_log_mistake, context_store_pattern,<br/>context_search, context_get_relevant, context_stats"]
end
subgraph "Engines"
O[Orchestrator :5001]
A[Agentic Team :5002]
D[Context Dashboard :5003]
end
CD & LA & PY & REPL -->|MCP Protocol| CORE & CODE & SEC & TEST & DEVOPS & CTX
CORE --> O & A
CTX --> D
[!TIP]
The MCP server is entirely optional. Both the Orchestrator and Agentic Team work fully via their own CLIs and Web UIs without it. Use python -m mcp_server repl for an interactive REPL to explore and test tools from the terminal.
Contributing
Contributions are welcome. Please see CONTRIBUTING.md for guidelines.
Fork the repository.
Create a feature branch: git checkout -b feature/your-feature
For security issues, please email [email protected]. Do not open public issues for security vulnerabilities. See SECURITY.md for the full security policy.
License
This project is licensed under the MIT License. See LICENSE for details.
Easter egg: Go to our wiki page and enter Konami code (↑ ↑ ↓ ↓ ← → ← → B A) for a surprise!
A
AI Agents Orchestrator
hoangsonww·97 estrelas·
🪈 Intelligent orchestration system that coordinates multiple AI coding assistants (Claude, Codex, Gemini CLI, Copilot CLI) to collaborate on complex software development tasks via REPL or a Vue/Nuxt
🪈 Intelligent orchestration system that coordinates multiple AI coding assistants (Claude, Codex, Gemini CLI, Copilot CLI) to collaborate on complex software development tasks via REPL or a Vue/Nuxt UI dashboard. Also includes an Agentic Team runtime with role-based multi-agent open communication & lead-gated final responses.
Ferramentas
Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Perguntas
Como instalo AI Agents Orchestrator?
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
AI Agents Orchestrator precisa de uma chave de API?
Este registro não lista nenhuma variável de ambiente obrigatória.
Qual transporte AI Agents Orchestrator usa?
AI Agents Orchestrator roda localmente via stdio.
Quando AI Agents Orchestrator foi verificado pela última vez?
Última verificação: 2026-10-27. 🪈 Intelligent orchestration system that coordinates multiple AI coding assistants (Claude, Codex, Gemini CLI, Copilot CLI) to collaborate on complex software development tasks via REPL or a Vue/Nuxt UI dashboard. Also includes an Agentic Team runtime with role-based multi-agent open communication & lead-gated final responses.