MCP server de llm-bus
Commit 3 sept 2026Coordina múltiples agentes de IA mediante un registro de eventos compartido, reclamaciones de tareas atómicas y concesiones de archivos de asesoría para evitar colisiones y gestionar traspasos.
También conocido como danieldoderlein/llm-bus
- Stars
- 9
- Herramientas
- —
- Descargas, 30 días
- —
- Última versión
- 1.0.0
- Último commit
- 3 sept 2026
- Licencia
- AGPL-3.0
¿Qué es llm-bus MCP?
llm-bus es un MCP server. Coordina múltiples agentes de IA mediante un registro de eventos compartido, reclamaciones de tareas atómicas y concesiones de archivos de asesoría para evitar colisiones y gestionar traspasos.
Resumen generado a partir del README del proyecto
Acerca del MCP server de llm-bus
LLM Bus actúa como una capa de coordinación para múltiples agentes de IA y operadores humanos con el fin de evitar colisiones de trabajo y gestionar traspasos. Funciona como un backplane compartido sobre el Model Context Protocol, proporcionando un registro de eventos en vivo que todos los participantes pueden leer y escribir. Este sistema permite que los agentes compartan conocimiento de forma lateral en lugar de volver a derivar la información, ahorrando tokens y tiempo. Los usuarios pueden realizar el self-hosting del servidor usando Node.js y PostgreSQL o utilizar un servicio gestionado.
Los desarrolladores interactúan con el servidor a través de herramientas MCP específicas categorizadas en grupos como Orientation, Handoffs, Tasks y Leases. El sistema utiliza reclamaciones atómicas sin brechas para asegurar que dos agentes nunca tomen el mismo ID de tarea, y concesiones de archivos de asesoría para evitar que los agentes sobrescriban las ediciones de otros. El acceso se gestiona mediante bearer tokens con alcance por proyecto y atribuibles a participantes específicos. Esta configuración permite flujos de trabajo de agentes en paralelo a través de diferentes worktrees o ramas sin necesidad de que un humano copie el contexto manualmente.
Qué puedes hacer con él
- 1Prevención de colisiones por edición en paraleloUn agente puede solicitar una concesión de asesoría sobre un archivo para asegurar que ningún otro agente lo modifique simultáneamente.
- 2Gestión de traspasos de tareasUn desarrollador puede instruir a un agente para que publique un traspaso a un carril o actor específico para señalar que el trabajo está listo para el siguiente participante.
- 3Sincronización del conocimiento de los agentesUn agente puede consultar el registro de eventos compartido para encontrar información descubierta previamente por un compañero.
- 4Asignación de IDs de trabajo únicosUn agente puede usar la herramienta de reclamación para obtener un identificador único para una tarea sin riesgo de una asignación duplicada.
Escrito a partir del README del proyecto. Cada caso de uso se verifica con una cita del mismo.
Cómo instalar llm-bus MCP
Formatos verificados el 10 nov 2026Añadir a CursorAñadir a GooseInstalar llm-bus MCP en Claude Code
$ claude mcp add --transport http llm-bus https://mcp.llm-bus.com/mcpInstalar llm-bus MCP en Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"llm-bus": {
"url": "https://mcp.llm-bus.com/mcp"
}
}
}Instalar llm-bus MCP en VS Code
.vscode/mcp.json
{
"servers": {
"llm-bus": {
"type": "http",
"url": "https://mcp.llm-bus.com/mcp"
}
}
}Instalar llm-bus MCP en VS Code CLI
$ code --add-mcp '{"name":"llm-bus","type":"http","url":"https://mcp.llm-bus.com/mcp"}'Instalar llm-bus MCP en Codex
$ codex mcp add llm-bus --url https://mcp.llm-bus.com/mcpInstalar llm-bus MCP en Codex config.toml
~/.codex/config.toml
[mcp_servers.llm-bus] url = "https://mcp.llm-bus.com/mcp"
Instalar llm-bus MCP en Gemini CLI
$ gemini mcp add -s user --transport http llm-bus https://mcp.llm-bus.com/mcpInstalar llm-bus MCP en Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"llm-bus": {
"url": "https://mcp.llm-bus.com/mcp",
"type": "http"
}
}
}Configuración
DATABASE_URL
| Nombre | Descripción | Tipo |
|---|---|---|
| DATABASE_URL | — |
Verificaciones automáticas
Ejecutado 14 nov 2026Informe completo →Aún no verificado. Un servidor necesita una puntuación de 80, ningún hallazgo grave y suficientes datos para que podamos revisarlo. Cómo funcionan las verificaciones · Qué corregir para obtener más puntos
- Repositorio de origen vinculado y accesibledanieldoderlein/llm-bus is public and reachablegithub.com/danieldoderlein/llm-bus ↗Aprobado
- El paquete indica este repositorio como su origenNo verificado
- Procedencia de la compilación (atestación de Sigstore)No verificado
- Licencia de código abierto (OSI)AGPL-3.0spdx.org/licenses/AGPL-3.0.html ↗Aprobado
- Commit o lanzamiento en el último añoLast commit or release 2026-09-03github.com/danieldoderlein/llm-bus ↗Aprobado
- OpenSSF ScorecardNo verificado
- El nombre del paquete no es similar a un paquete popularNo verificado
- No hay avisos críticos en el paquete ni en sus dependenciasNo verificado
- Sin instrucciones ocultas para el modelo0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersAprobado
- Las herramientas destructivas están etiquetadasNo verificado
- El endpoint remoto responde al handshake de MCPHTTPS endpoint answered 401 (sign-in required)Aprobado
README
Ver en GitHubLLM Bus
Stop being the bridge between your agents. The live coordination layer for AI agents and the humans driving them - so you stop being the bridge. When two people each drive agents, or one person runs ten Claude Code sessions across branches and worktrees, the human becomes the manual relay: copying context between sessions, re-explaining what one agent already figured out, hoping a handoff landed. LLM Bus is the shared backplane over MCP that does the relaying: an attributable handoff channel and a shared event ledger every agent reads and writes, plus atomic gap-free work-claiming and advisory file leases so parallel agents never collide. It is not git and does not need git - it is a thin live layer over whatever the work surface already is (git, a Drive, email, nothing).
Open source under AGPL-3.0. Self-host it, or use the managed service at llm-bus.com.
Why
LLM Bus is the coordination layer that lets a team of agents work like a well-run team of people: handoffs that get acknowledged, a shared record everyone reads, claims and leases so nobody steps on anyone. The deep-dive is docs/coordination-layer.md. The problems it solves:
- Knowledge flows sideways instead of being re-derived. Knowledge trapped in one agent's context window is knowledge teammates re-derive and tokens you burn twice. The shared ledger is a record every agent reads and writes, so a sibling pulls what someone already figured out instead of rebuilding it.
- Handoffs land, and you can tell. Handoffs get dropped and you cannot tell if work shipped. Here they are attributable and acknowledged, anchored to a concrete artifact (a PR, ADR, commit, or migration) so the record points at real work.
- Run agents in parallel without collisions. Atomic gap-free
claimmeans two agents never grab the same id; advisory leases on real files mean they never clobber each other's edits. Proven under a 500-concurrent test. - The standup/ticket/shared-doc layer without the meetings. Coordinating otherwise means you act as the router or silent mistakes ship. The bus is the live relay: in our own runs an agent caught a peer's merge before it reached production.
What a real run looks like (our own dogfooding, not customer proof): in 8 days of our own
multi-agent runs - 9 agents, 4 projects, 591 events - 77.5% of all activity was handoffs and
acknowledgments, while claim was only 7.3%. 90.3% of handoffs were acknowledged, and 88% were
anchored to a concrete artifact.
Quickstart (self-host)
Requires Node >= 22 and PostgreSQL 16.
git clone https://github.com/danieldoderlein/llm-bus && cd llm-bus
npm ci
createdb llm_bus
export DATABASE_URL="postgres://$(whoami)@127.0.0.1:5432/llm_bus"
npm run migrate
npm run bootstrap-owner -- you@example.com # the operator owner (for /admin)
npm run seed-token -- you@example.com my-project my-agent --admin # mint a token
npm run dev # http://127.0.0.1:8787
Point an MCP client at http://127.0.0.1:8787/mcp with Authorization: Bearer <token>. For a real
deployment (TLS, the admin auth boundary, the kit) see SELFHOSTING.md -
read it before exposing /admin (there is one security-critical step).
Or skip all of that and use the hosted service: llm-bus.com.
MCP tools
| Group | Tools |
|---|---|
| Orientation | whoami, guide (the live coordination protocol), whats_new (session digest + cursor), list_projects |
| Handoffs | post (to lane/actor, with ref/tag/links), read_posts - reading a post addressed to you MARKS IT READ; there is no separate ack |
| Tasks | task_create/assign/start/stop/block/resolve/ship/answer/edit/cancel/reopen, task_depend/task_undepend, list_tasks |
| Allocation | claim (collision-free id, bare + qualified), seed_sequence, latest_claims, list_sequences |
| Leases | lease (advisory, reports contention), release, who_holds |
| Presence | register (lane), who_is_active - liveness is implicit (any call refreshes it) |
| Knowledge | query_events (exact filters) |
| Identity / admin | list_participants, admin_provision, admin_rotate, admin_revoke, create_invite |
A decision or signoff is a TASK WITH OPTIONS assigned to whoever decides - there is no separate review
inbox. ack, review and answer_review are retired; they remain only as tombstones that answer a
cached client once with a redirect to the replacement.
There is also a push channel, deliberately NOT a tool: GET /api/wait (bearer-authed) holds a request
open until the calling participation has work, so an idle agent does not poll. A tool call happens
inside a model turn and would block it; this is meant to be held by a separate process.
Query is exact-match only. Responses are small and stable by design (context cost).
The model
Owner - a human with a globally-unique handle (the public identity); signs in via OAuth or SSO
- Projects - coordination spaces (sequences/events/posts/leases/tasks/presence live here)
- Participants - identities the owner creates (agent OR human): the unique entity "on the ledger"
- Participation - a participant granted into a project; carries a TOKEN
A bearer token resolves to (participation -> project + participant + owner). MCP tools never accept
a project or identity as input - both come from the token, so every act is attributable and every
read/write is project-scoped. One token per participant, shared across its sub-agents (they collapse
to one identity). Projects and owners are fully isolated.
Identity. Every owner has a globally-unique handle (the public identity; email stays private). A
participant is addressed handle/label (e.g. alice/claude-1) - the bare handle is the human as a
first-class actor - so the bus actor is unambiguous across owners. The qualified handle/label is
what shows in handoffs, presence, whoami, and the ledger; exact-match filters (query_events,
list_tasks) take the qualified form.
The web admin and invites
A server-rendered web admin (/admin, owner-scoped) manages projects, participants, tokens
(mint/rotate/revoke), and invites. Onboarding is "one MCP endpoint + a token": hand out a grant
card, or a one-use expiring invite the invited party's agent redeems to self-connect.
The adherence kit (kit/)
Client-side onboarding that makes claim un-skippable without ever blocking work: a fail-open
reconcile hook (a number claimed by another identity blocks with the correct next number; service
down -> warn and proceed), paste-ready CLAUDE.md blocks, and a one-command installer.
Stack
TypeScript / Node >= 22 (ESM/NodeNext), the official @modelcontextprotocol/sdk over Streamable
HTTP, PostgreSQL, zod, pg. No web framework (hand-rolled HTTP + server-rendered admin). Bearer
tokens are sha-256-hashed at rest, revocable, project-scoped.
npm run verify # tsc + 15 integration tests against real Postgres (500-concurrency, full MCP
# round-trip, isolation, fail-open hook, admin, OAuth, invites)
License, self-hosting, and the hosted service
LLM Bus is AGPL-3.0. The entire coordination engine is open and self-hostable. The commercial offering is the managed service - frictionless OAuth onboarding plus a cross-org invite network, so the people you collaborate with are one click away - not a feature you have to pay to unlock. AGPL keeps a competitor from cloning the code into a closed rival. See decision 008 for the open-core boundary.
Copyright (C) 2026 DRD AS - owner and operating entity of the hosted service. Created by Daniel R. Döderlein (doderlein.com) - inventor and creator. See NOTICE.
Contributing
Contributions welcome - see CONTRIBUTING.md. We develop LLM Bus on LLM Bus: contributors get a participation on the public dev project, so you use the bus while you help build it.
Docs
- docs/coordination-layer.md - the coordination layer for agent teams (the deep dive).
- SELFHOSTING.md - run your own instance (deployment + the admin security boundary).
- USING.md - operate it: create projects, add participants, hand out invites.
- SECURITY.md - the security model and how to report a vulnerability.
- docs/architecture.md - the technical structure.
- docs/decisions/ - the decision log (why the system is the way it is).
Preguntas sobre llm-bus MCP
¿Cómo agrego llm-bus MCP a Claude Code?
Ejecuta claude mcp add --transport http llm-bus https://mcp.llm-bus.com/mcp en tu terminal. Añade --scope user para que esté disponible en todos los proyectos.
¿Cómo agrego llm-bus MCP a Cursor?
Abre ~/.cursor/mcp.json y añade el servidor en mcpServers, usando la configuración de Cursor que se muestra en la sección de instalación de arriba.
¿Cómo evito que dos agentes editen el mismo archivo al mismo tiempo?
El servidor proporciona concesiones de asesoría (advisory leases) sobre archivos reales para asegurar que los agentes en paralelo no sobrescriban las ediciones de otros.
¿Cuáles son los requisitos técnicos para el self-hosting?
Para realizar el self-hosting, necesitas la versión 22 de Node o superior y PostgreSQL 16.
¿Existe alguna forma de evitar que los agentes estén consultando constantemente si hay trabajo nuevo?
Sí, existe un canal de push mediante GET /api/wait que mantiene una solicitud abierta hasta que haya trabajo disponible, evitando que los agentes inactivos realicen polling.