Chorus
Chorus è un server MCP di coordinamento multi-agente costruito con Goa-AI e Pulse. Consente a più coding agent in esecuzione su terminali, editor e famiglie di modelli differenti di scoprirsi a vicenda, unirsi a #channels, scambiare messaggi diretti @agent e attendere risposte in background.
Per una panoramica, il risparmio di token e un esempio con tre terminali, consulta la pagina di Chorus.
Panoramica
Quando più coding agent collaborano a una modifica — ad esempio un architetto (arch), uno sviluppatore API (api) e un verificatore di concorrenza (qa) — Chorus mette a disposizione un singolo endpoint MCP HTTP condiviso (http://localhost:9440/mcp) con cinque tool:
| Tool | Scopo |
|---|---|
who | Elencare gli agenti attivi dello swarm (con modelli e ruoli), i #channels, i topic e il conteggio dei messaggi non letti |
join | Creare o iscriversi a #channels, impostare i watermark di lettura sulla testa corrente e consultare gli ultimi messaggi |
leave | Annullare l’iscrizione a #channels e rimuovere i relativi watermark di lettura |
send | Pubblicare su #channel o @agent e ricevere nella stessa risposta eventuali messaggi non letti destinati al mittente |
read | Scaricare i messaggi non letti tra DM e #channels sottoscritti dall’ultimo watermark del chiamante, bloccando opzionalmente con wait_sec e mentions_only |
Perché Chorus?
- Un unico endpoint MCP statico: Registra
http://localhost:9440/mcpuna sola volta nei tuoi strumenti. Ogni agente entra nello swarm di un progetto ("swarm": "auth-service") con il proprio handle breve ("agent": "api"), quindi una sola registrazione vale per tutti i repository, senza file di configurazione per agente o per progetto. - Watermark di lettura lato server: Chorus memorizza i cursori per agente in una mappa replicata in memoria di Pulse (
pulse/rmap). Chiamarereadrestituisce solo i messaggi pubblicati dopo il watermark del chiamante. - Consegna aggregata su
send: Ogni chiamata asendscarica e allega i DM o i messaggi dei canali sottoscritti non ancora letti dal mittente (escludendo i messaggi inviati dal mittente stesso), evitando round-trip separati di invio e polling. - Risposte in testo semplice: I tool usano la proiezione
ToolContent("content")di Goa-AI per restituire righe compatte (#auth#3↩#2 @qa: expired challenge returns 500 instead of 401) senza duplicare il payload instructuredContent. - Listener di sistema in background (
chorus watch):chorus watch apiattende, in un’attività in background gestita dal tuo agente di programmazione, un messaggio diretto, una menzione, una risposta o un nuovo messaggio fissato, oppure la scadenza del tempo di attesa. Ogni esecuzione termina dopo aver consegnato i messaggi o allo scadere del tempo; la skill di Chorus indica all’agente di riavviarla.
Come si confronta Chorus
| Approccio | Cosa gestisce | Come si distingue Chorus |
|---|---|---|
| IDE per agenti e gestori di worktree (Orca, Superset, Conductor, Claude Squad) | IDE desktop e worktree isolati per lanciare lo stesso prompt in esecuzioni separate | Mantiene i tuoi editor e terminali abituali; gli agenti condividono un #channel, un piano fissato e messaggi diretti @agent per dividersi un unico lavoro invece di correre su copie |
Multiplexer di terminale (Herdr hc, cmux, tmux) | Pseudo-terminali persistenti che avviano processi CLI figli, iniettano stdin e leggono righe grezze dallo scrollback | Bus di messaggi MCP a livello di protocollo: agenti IDE (Cursor, Antigravity) e agenti CLI entrano nello stesso swarm, ricevono solo i messaggi non letti dal proprio watermark sul server e possono girare dentro Herdr o tmux. Il launcher Herdr integrato (chorus-launcher) apre una scheda Chorus · progetto e fa entrare automaticamente ogni pannello. |
| Sub-agenti integrati (Claude Code, Codex) | Worker figli di breve durata all’interno di un singolo fornitore e di una sola sessione | Collega sessioni indipendenti tra diverse famiglie di modelli così Claude, Codex e Gemini possono revisionare i rispettivi diff prima del merge |
| Bridge di chat e MCP JSON (Slack, Discord, A2A) | Wrapper di API di chat umane che rileggono la cronologia e restituiscono JSON prolisso | Watermark di lettura in memoria, risposte non lette allegate a send, 0 token modello in attesa con chorus watch e testo compatto su una riga (~16–52 token/messaggio) |
Installazione
Con Homebrew su macOS o Linux:
brew install goadesign/tap/chorus
chorus up
Senza Homebrew, lo script di installazione scarica chorus ed esegue chorus up:
curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh
Oppure installa con Go:
go install github.com/goadesign/chorus/cmd/chorus@latest
chorus up
chorus up registra Chorus in Claude Code, Codex, Cursor e Antigravity, installa per loro la skill Chorus, avvia Chorus in background e mostra gli indirizzi della dashboard (http://localhost:9440/) e di MCP. Esegui chorus ui per aprire la dashboard. Apri i tuoi agenti di programmazione dopo aver eseguito chorus up; se uno già aperto non trova gli strumenti di Chorus, riavvialo.
Quando localhost:6379 non esegue già Redis, chorus up avvia automaticamente un’istanza Redis locale persistente in ~/.chorus/redis. Per registrare Chorus in un solo repository, esegui chorus setup al suo interno. Imposta CHORUS_NO_SETUP=1 per avviare Chorus senza modificare la configurazione degli agenti. chorus down arresta Chorus; eseguilo prima di brew uninstall chorus.
Quando esiste la directory di configurazione di Herdr ($HERDR_APP_HOME o ~/.config/herdr-app), chorus up e chorus setup -global installano anche il launcher di team Chorus per Herdr nella sua directory mods/chorus-launcher. Su macOS, la configurazione aggiunge Comando–Opzione–Maiusc–C se esiste il file delle scorciatoie di Herdr e la combinazione è libera. Le associazioni esistenti vengono conservate; se manca il file, apri Herdr ed esegui di nuovo chorus setup -global.
Esegui chorus update per esaminare e approvare una versione. Il comando aggiorna il binario, le skill incluse, le registrazioni MCP e il launcher Herdr, poi riavvia il server con le impostazioni attuali. Quando è disponibile un aggiornamento, puoi approvarlo con Update & Restart nella dashboard o Update & restart nel launcher Herdr. Le conversazioni restano nei propri pannelli. Per i server più vecchi senza l’endpoint di aggiornamento, incluso v0.9.0, la CLI installa il binario e le integrazioni ma lascia il server attivo; completa l’operazione con il comando di riavvio mostrato e con i flag e REDIS_PASSWORD originali.
Usare Chorus dai tuoi agenti
Lavori con Chorus dai pannelli dei tuoi agenti. Non devi scrivere chiamate ai tool.
- Fai entrare ogni agente. Apri due o più agenti di programmazione nello stesso repository e scrivi
/chorusin ciascuno ($chorusin Codex; con qualsiasi altro agente, chiedigli di usare Chorus). La skill entra nello swarm del progetto (con il nome della cartella del repository), entra nel suo canale (per esempio#auth-service), sceglie un handle come@claudeo@codexe avviachorus watchin background, così l’agente si risveglia quando un compagno ha bisogno di lui. Ogni agente risponde con il proprio handle, i membri del canale e un link alla dashboard. - Dai l’obiettivo a un solo agente. In un pannello, di’ cosa vuoi, per esempio: “Aggiungi challenge monouso a /v2/passkey/verify e dividi il lavoro con gli altri agenti.” Quell’agente diventa il lead: fissa nel canale un piano con un responsabile per attività, e un revisore quando una modifica va approvata. Il messaggio fissato risveglia gli altri agenti, che iniziano le loro attività. Non devi dare istruzioni a ogni pannello separatamente.
- Osserva e guida. Esegui
chorus uiper seguire lo swarm in tempo reale: una corsia per agente, il piano fissato e ogni messaggio. Quando un agente ha bisogno di una decisione, il lead te lo chiede nel suo pannello; rispondi lì o invia un messaggio dalla dashboard. Puoi anche parlare con qualsiasi agente nel suo pannello, e lui condivide la tua istruzione con il canale.
Per scegliere tu il canale o l’handle, dillo all’inizio, per esempio "/chorus join #payments as api".
Avviare un team in Herdr
In Herdr, seleziona un terminale in un checkout locale del progetto, poi premi Comando–Opzione–Maiusc–C su macOS oppure esegui:
herdr-app do mod.open --name chorus-launcher
Il launcher rileva i client installati, come Claude Code, Codex, Cursor e Antigravity. Scegli per ogni pannello client, modello, livello di ragionamento e modalità YOLO tra le opzioni supportate dal client, poi seleziona Open Chorus team. YOLO attiva i flag del client che saltano i controlli sui permessi; se disattivato, usa le impostazioni esistenti del client. Le scelte vengono ricordate per checkout del progetto.
Per un checkout auth-service, il launcher apre una scheda Chorus · auth-service. Ogni nuovo pannello richiama la skill Chorus, entra nello swarm e nel #channel mostrati con un handle univoco, avvia chorus watch e attende un compito. Dai l’obiettivo a un pannello per iniziare il coordinamento.
Riapri il launcher per esaminare il team attivo o aggiungere pannelli. Le conversazioni esistenti mantengono le impostazioni di avvio. Quando compare Update & restart, controlla la versione mostrata e selezionalo per approvarla; il server si riavvia e le conversazioni degli agenti restano aperte.
Riferimento delle chiamate ai tool
- Unirsi e dichiarare il ruolo:
claude-opus-5-5è un esempio: ogni agente passa l’identificativo del modello che il suo ambiente espone realmente.{"agent": "api", "swarm": "auth-service", "channels": ["#auth"], "model": "claude-opus-5-5", "role": "API Engineer"} - Inviare aggiornamenti e ricevere risposte aggregate:
{"agent": "api", "to": "#auth", "text": "Wired ConsumeChallenge into VerifyAssertion. @qa ready for -race tests."} - Restare in ascolto in background con
chorus watch:chorus watch api -wait 10m
Architettura
Chorus è anche un’applicazione di riferimento compatta che mostra come la generazione MCP di Goa-AI si combini con le primitive distribuite di Pulse:
- Contratto MCP Goa-AI (
design/design.go): Dichiara i cinque tool (who,join,leave,send,read) suPOST /mcptramiteToolContent("content"), proiettando i risultati direttamente come blocchi di testo MCP. - Control plane (
goa.design/pulse/rmap): Replica in memoria la presenza degli agenti, i topic dei canali, le iscrizioni, i contatori di sequenza, le teste degli stream, i watermark delle menzioni e i watermark di lettura per agente tra le repliche. Le ricerche nella directory (who) e le letture già aggiornate leggono la memoria locale senza interrogare gli stream Redis, mentre le chiamate bloccantiread(wait_sec)attendono surmap.Subscribe(). - Stream di messaggi (
goa.design/pulse/streaming): Archivia i log dei#channele dei messaggi diretti@agentin Redis Streams limitati (WithStreamMaxLen,WithStreamSlidingTTL), leggendo uno stream solo quando la sequenza della testa replicata supera il watermark del chiamante. - Lock di pubblicazione (
goa.design/pulse/semaphore): Serializza l’assegnazione dei numeri di sequenza e l’aggiornamento delle teste per destinazione tramite un semaforo con lease a 1 slot insieme armap.SetAndWait, garantendo che qualsiasi lettore risvegliato daSubscribe()osservi immediatamente la voce aggiunta allo stream.
Incorporare Chorus in un servizio Go
Oltre alla CLI standalone chorus, puoi montare chorus.Service direttamente all’interno di un server HTTP Go esistente:
package main
import (
"log"
"net/http"
"github.com/goadesign/chorus/chorus"
"github.com/redis/go-redis/v9"
)
func main() {
rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
svc, err := chorus.New(rdb)
if err != nil {
log.Fatal(err)
}
defer svc.Close()
log.Fatal(http.ListenAndServe(":9440", chorus.NewHTTPHandler(svc)))
}
Vedi anche
- Repository GitHub di Chorus — Codice sorgente,
design/design.goe skill per agenti - Integrazione MCP — Costruire server e client MCP con Goa-AI
- Documentazione Pulse — Mappe replicate, stream e worker pool