# The open-source ACP orchestrator

> Source: <https://github.com/alfonsodg/aintegrix>
> Published: 2026-05-26 03:26:05+00:00

**The open-source ACP orchestrator. One API. Five agents. Infinite possibilities.**

AIntegriX is the first **open-source ACP orchestrator** — a server that coordinates multiple [Agent Client Protocol](https://agentclientprotocol.com) agents through a single API.

The **Agent Client Protocol** (ACP) is the open standard that connects code editors with AI coding agents — the same way LSP standardized language servers. Every major coding agent now speaks ACP: Kiro, GitHub Copilot, Claude Code, OpenCode, Codex CLI, and [30+ more](https://agentclientprotocol.com/agents).

Each ACP agent runs independently. You can't:

- Ask one agent to delegate work to another
- Send the same prompt to multiple agents and compare
- Chain agents in a pipeline (generate → review → fix)
- Auto-trigger agents on Git events

AIntegriX acts as an **ACP multiplexer**. It spawns agents as subprocesses, speaks JSON-RPC 2.0 over stdio with each one, and exposes them all through a single MCP/REST endpoint.

```
Your Agent (any MCP-compatible tool)
       │
       ▼ MCP / REST
┌─────────────────────────────────┐
│         AIntegriX               │
│   Route • Orchestrate • Stream  │
│         (ACP Client)            │
└──┬──────┬──────┬──────┬──────┬──┘
   │      │      │      │      │   JSON-RPC 2.0 / stdio
   ▼      ▼      ▼      ▼      ▼
 Kiro  Copilot OpenCode Claude Codex
 (ACP)  (ACP)   (ACP)  (ACP)  (ACP)
```

**One prompt. Any agent. Real results.**

| Problem | Solution |
|---|---|
| Each agent has different strengths | Smart routing picks the best agent for each task |
| Can't compare agent responses | Orchestration sends to N agents in parallel |
| No way to chain agent work | Pipelines feed output from one agent to the next |
| Agents can't read your latest code | Auto-clone from your Git remote or direct local filesystem |
| Responses arrive all at once | SSE streaming shows chunks in real-time |
| Manual code review requests | Webhooks auto-trigger review on MR open |

```
┌─────────────────────────────────────────────────────────────┐
│                    YOUR DEVELOPMENT FLOW                      │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  1. Code locally                                             │
│       │                                                      │
│  2. Ask AIntegriX:                                           │
│       "Review src/ for security issues"                      │
│       │                                                      │
│  3. AIntegriX routes to Claude (security expert)             │
│       │                                                      │
│  4. Claude reads your files, analyzes, responds              │
│       │                                                      │
│  5. You get the review in your agent's context               │
│                                                              │
│  ─── OR ───                                                  │
│                                                              │
│  Pipeline: OpenCode generates → Claude reviews → Kiro fixes  │
│                                                              │
│  ─── OR ───                                                  │
│                                                              │
│  Race: Send to 3 agents, first response wins                 │
│                                                              │
└─────────────────────────────────────────────────────────────┘
# Install
git clone git@github.com:alfonsodg/aintegrix.git
cd aintegrix
cargo build --release
./configs/install.sh ~/.local/share/aintegrix

# Add to your agent's MCP config
{
  "mcpServers": {
    "aintegrix": {
      "command": "mcp-proxy",
      "args": ["-H", "Authorization", "Bearer aintegrix-local-key-2026",
               "--transport", "streamablehttp", "http://localhost:8050/mcp"],
      "env": {}
    }
  }
}
{
  "mcpServers": {
    "aintegrix": {
      "url": "https://your-server.example.com/mcp",
      "type": "http",
      "headers": {"Authorization": "Bearer <token>"}
    }
  }
}
```

| Agent | Model | Best For |
|---|---|---|
🧠 Kiro |
claude-opus-4.6 | Rust, architecture, complex reasoning |
🤖 Copilot |
gpt-5.3-codex | Frontend, React, quick edits |
⚡ OpenCode |
mimo-v2.5-pro | Fast analysis, multi-file reads |
🔍 Claude |
minimax-2.7 | Security review, deep analysis |
🛠️ Codex |
gpt-5.5-xhigh | Python, refactoring, generation |

**5 ACP agents** with real subprocess management**MCP server**— any agent can use AIntegriX as a tool** REST API**with Bearer auth** SSE streaming**of agent responses in real-time

**Parallel**— send to N agents, collect all responses** Race**— first response wins, cancel others** Jury**— N agents respond, a judge picks the best** Pipelines**— sequential multi-step workflows

**Auto-routing**— YAML rules pick the best agent by keywords/file patterns** Prompt rewriting**— per-agent prefix/suffix** Git-aware sessions**— inject branch, commits, diff as context** Context injection**— auto-load steering files

**Auto-clone repos**— fresh checkout from your Git remote (remote mode)** Local filesystem**— direct access to your code (local mode)** Webhook triggers**— MR/PR → auto code review** Session fork**— try same conversation with different agent** Cost tracking**— usage per agent/session/model** Live status**— agent idle/busy with session counts

| Method | Endpoint | Description |
|---|---|---|
| POST | `/api/v1/sessions` |
Create session |
| POST | `/api/v1/sessions/{id}/prompt` |
Send prompt |
| POST | `/api/v1/sessions/{id}/fork` |
Fork to another agent |
| POST | `/api/v1/orchestrate` |
Multi-agent (parallel/race/jury) |
| POST | `/api/v1/pipelines` |
Sequential agent chaining |
| POST | `/api/v1/stream` |
Create + stream SSE |
| POST | `/api/v1/webhooks/git` |
Receive webhook events |
| GET | `/api/v1/agents/status` |
Live agent status |
| GET | `/api/v1/usage` |
Cost tracking |
| POST | `/mcp` |
MCP JSON-RPC endpoint |

| Layer | Technology |
|---|---|
| Language | Rust (latest stable) |
| Runtime | tokio |
| HTTP | axum |
| Protocol | ACP (JSON-RPC 2.0 over stdio) |
| Database | SQLite (sqlx) |
| Config | YAML |

Apache-2.0

Built with 🦀 Rust • Powered by ACP