Welches Problem wird gelöst?

Wenn Sie mehrere KI-Agenten (Claude Code, OpenClaw, WorkBuddy, benutzerdefinierte Agenten…) ausführen, arbeiten diese in Silos. Sie können nicht:

Miteinander kommunizieren, ohne fehleranfällige Webhooks oder gemeinsame Datenbanken
Aufgaben planen über Agentengrenzen hinweg
Kontext teilen über One-Shot-Prompts hinaus
Gemeinsam wachsen als Team basierend auf vergangenen Erfahrungen

Agent Communication Hub verleiht jedem MCP-kompatiblen Agenten ein gemeinsames Nervensystem – Message Bus, Aufgabenwarteschlange, Speicherebene und Evolutions-Engine –, damit Agenten zusammenarbeiten, anstatt isoliert zu agieren.

In 3 Zeilen ausprobieren

# 1. Start the Hub
docker run -d -p 3100:3100 --name ach liuboacean/agent-comm-hub

# 2. Register an agent
python3 -c "from hub_client import SynergyHubClient; print(SynergyHubClient('http://localhost:3100').register('YOUR_INVITE_CODE'))"

# 3. Send a message
python3 -c "from hub_client import SynergyHubClient; c=SynergyHubClient('http://localhost:3100'); c.set_token('YOUR_TOKEN'); c.send_message(to='other-agent', content='Hello!')"

Keine Konfigurationsdateien. Keine externen Dienste. Funktioniert lokal.

Funktionen auf einen Blick

Kategorie	Tools	Was es tut
Identität	6	Agenten registrieren, Heartbeat, RBAC-Rollen, Vertrauens-Scoring
Messaging	5	P2P / Broadcast, FTS5-Suche, Deduplizierung
Aufgabenplanung	8	7-Zustands-Maschine, Pipelines, parallele Gruppen, Auto-Retry
Speicher	5	Private / Team / kollektive Bereiche, Edge-Function-Scoring
Orchestrierung	11	Abhängigkeitsketten (DFS-Zykluserkennung), Quality Gates, Übergabeprotokolle
Evolution	12	Erfahrungsaustausch, 4-stufige Strategie-Genehmigung, Vertrauens-Score-Feedbackschleife
Sicherheit	6	Token-Authentifizierung, 4-stufiges RBAC, Audit-Hash-Kette, CORS-Whitelist
Dateien	3	Hochladen / Herunterladen / Auflisten, bis zu 10 MB Base64

53 MCP-Tools · SQLite WAL (kein Nachrichtenverlust) · SSE-Push-Latenz < 50 ms

Architektur

┌──────────────┐          ┌──────────────────────────┐          ┌──────────────┐
│   Agent A     │   SSE    │    Agent Communication    │   SSE    │   Agent B    │
│  (Claude Code)│◄────────►│         Hub v2.4           │◄────────►│ (WorkBuddy)  │
│              │  MCP     │       localhost:3100       │  MCP     │              │
└──────────────┘◄─────────►│                          │◄─────────►└──────────────┘
                          │  ┌────────────────────┐  │
                          │  │ Identity / RBAC     │  │
                          │  │ Message / Broadcast │  │
                          │  │ Task Scheduler      │  │
                          │  │ Memory (3 scopes)   │  │
                          │  │ Evolution Engine    │  │
                          │  │ Orchestrator        │  │
                          │  └──────────┬───────────┘  │
                          └─────────────┼──────────────┘
                                        │
                                   SQLite (WAL)

Jeder MCP-kompatible Agent kann eine Verbindung herstellen: Claude Code, OpenClaw, WorkBuddy, Hermes, benutzerdefinierte Agenten usw.

SDK-Beispiele

Python — null Abhängigkeiten

from hub_client import SynergyHubClient

hub = SynergyHubClient(hub_url="http://localhost:3100", agent_id="my-agent")
hub.set_token("your-api-token")

# Send a message
hub.send_message(to="workbuddy", content="Task completed, handing over.")

# Store shared memory
hub.store_memory(content="User prefers JSON responses", scope="collective")

# Assign a task
task = hub.create_task(title="Review PR #42", assignee="claude-code", priority=2)

# Share a lesson learned
hub.share_experience(title="DB lock timeout fix", content="...", category="debug")

# Stream incoming events
hub.on_message = lambda msg: print(f"Received: {msg}")
hub.connect_sse()  # blocks — long-lived SSE connection

TypeScript — ebenfalls null externe Abhängigkeiten

import { AgentClient } from "./client-sdk/agent-client.js";

const client = new AgentClient({
  agentId: "my-agent",
  hubUrl: "http://localhost:3100",
  token: "your-api-token",
  onMessage: async (msg) => { /* handle */ },
  onTaskAssigned: async (task) => { /* handle */ },
});

await client.start();
await client.sendMessage({ to: "workbuddy", content: "Done!" });

Bereitstellung

Docker (empfohlen)

docker run -d -p 3100:3100 --name ach liuboacean/agent-comm-hub

Docker Compose (mit Prometheus + Grafana)

cd deploy && docker compose up -d
# Hub:  http://localhost:3100
# Grafana: http://localhost:3000 (admin/admin)
# Prometheus: http://localhost:9090

Aus dem Quellcode

git clone https://github.com/liuboacean/agent-comm-hub.git
cd agent-comm-hub
npm install && npm run build
npm start

Als Skill

# ClawHub
clawhub install liuboacean/agent-comm-hub

# SkillHub (30+ platforms)
npx skills add liuboacean/agent-comm-hub

MCP-Konfiguration

Nach dem Start des Hubs fügen Sie ihn zur MCP-Konfiguration Ihres Agenten hinzu:

Option 1: stdio (empfohlen)

{
  "mcpServers": {
    "agent-comm-hub": {
      "command": "node",
      "args": ["<hub-install-path>/stdio.js"],
      "env": {
        "HUB_KEY": "your-connection-key"
      }
    }
  }
}

Option 2: HTTP + SSE

{
  "mcpServers": {
    "agent-comm-hub": {
      "url": "http://localhost:3100/mcp"
    }
  }
}

Das LLM des Agenten kann dann alle 53 Tools direkt über natürliche Sprache aufrufen.

Sicherheit

Funktion	Detail
RBAC	4 Stufen: public → member → group_admin → admin
Token-Auth	SHA-256 Agenten-Token, als Hash in der DB gespeichert
Audit-Hash-Kette	`prev_hash → record_hash` mit DB-Triggern
Vertrauens-Scoring	Automatisch berechnet, beeinflusst Strategie-Genehmigungsstufen
CORS	Nur Whitelist, Standard-Ablehnung
Sicherheits-Header	X-Frame-Options, CSP, HSTS, X-XSS-Protection
Request-Tracing	traceId bei jeder Anfrage + Antwort-Header

Dateistruktur

agent-comm-hub/
├── src/                         # Hub server source (TypeScript)
│   ├── server.ts                # Express + SSE + MCP entry point
│   ├── db.ts                    # SQLite WAL schema + queries
│   ├── identity.ts              # Registration, heartbeat, RBAC
│   ├── memory.ts                # 3-scope memory with FTS5
│   ├── task.ts                  # 7-state task scheduler
│   ├── orchestrator.ts          # Dependency chains, pipelines
│   ├── evolution.ts             # Strategy engine, trust scoring
│   └── security.ts              # Auth, token, RBAC, audit
├── client-sdk/
│   ├── hub_client.py            # Python SDK (zero deps, 68 methods)
│   └── agent-client.ts          # TypeScript SDK (35 public methods)
├── deploy/
│   ├── docker-compose.yml       # Prometheus + Grafana observability
│   └── prometheus.yml           # Metrics scraping config
├── docs/
│   ├── API_REFERENCE.md         # 53 tools complete reference
│   ├── advanced-orchestration-guide.md
│   ├── evolution-engine-guide.md
│   └── hermes-integration-guide.md
├── scripts/
│   ├── install.sh               # Hub server install script
│   └── test-e2e.sh              # End-to-end test suite
└── tests/                       # Integration + unit tests

Dokumentation

Dokument	Wann zu lesen
API-Referenz	Jede Tool-Signatur + Beispiele
Orchestrierungs-Leitfaden	Pipelines, parallele Gruppen, Quality Gates
Evolutions-Engine	Vertrauens-Scoring, Strategie-Genehmigungs-Workflow
Hermes-Integration	Schritt-für-Schritt Hermes-Agenten-Einrichtung
README.md (Englisch)	Diese Seite

Lizenz

MIT — nutzen Sie es frei in persönlichen und kommerziellen Projekten.

Agent-Comm-Hub