MCP server llm-bus
Commit 3 de set. de 2026Coordena múltiplos agentes de IA por meio de um registro de eventos compartilhado, reivindicações atômicas de tarefas e concessões de arquivos consultivas para evitar colisões e gerenciar transferências de trabalho.
Também conhecido como danieldoderlein/llm-bus
- Stars
- 9
- Ferramentas
- —
- Downloads, 30 dias
- —
- Versão mais recente
- 1.0.0
- Último commit
- 3 de set. de 2026
- Licença
- AGPL-3.0
O que é o MCP llm-bus?
Coordena múltiplos agentes de IA por meio de um registro de eventos compartilhado, reivindicações atômicas de tarefas e concessões de arquivos consultivas para evitar colisões e gerenciar transferências de trabalho.
Resumo gerado a partir do README do projeto
Sobre o MCP server de llm-bus
O LLM Bus atua como uma camada de coordenação para múltiplos agentes de IA e operadores humanos para evitar colisões de trabalho e gerenciar transferências (handoffs). Ele funciona como um backplane compartilhado sobre o Model Context Protocol, fornecendo um registro de eventos ao vivo que todos os participantes podem ler e escrever. Esse sistema permite que os agentes compartilhem conhecimento lateralmente em vez de reprocessar informações, economizando tokens e tempo. Os usuários podem fazer o self-host do servidor usando Node.js e PostgreSQL ou utilizar um serviço gerenciado.
Desenvolvedores interagem com o servidor por meio de ferramentas MCP específicas categorizadas em grupos como Orientation, Handoffs, Tasks e Leases. O sistema utiliza reivindicações atômicas sem lacunas para garantir que dois agentes nunca peguem o mesmo ID de tarefa, e concessões de arquivos consultivas para evitar que agentes sobrescrevam as edições uns dos outros. O acesso é gerenciado via bearer tokens que possuem escopo de projeto e são atribuíveis a participantes específicos. Essa configuração permite fluxos de trabalho de agentes em paralelo em diferentes worktrees ou branches sem exigir a cópia manual de contexto por um humano.
O que você pode fazer com ele
- 1Prevenção de colisões de edição paralelaUm agente pode solicitar uma concessão consultiva em um arquivo para garantir que nenhum outro agente o modifique simultaneamente.
- 2Gerenciamento de handoffs de tarefasUm desenvolvedor pode instruir um agente a postar um handoff para uma lane ou ator específico para sinalizar que o trabalho está pronto para o próximo participante.
- 3Sincronização de conhecimento entre agentesUm agente pode consultar o registro de eventos compartilhado para encontrar informações descobertas anteriormente por um colega de equipe.
- 4Alocação de IDs de trabalho exclusivosUm agente pode usar a ferramenta de claim para obter um identificador único para uma tarefa sem o risco de uma atribuição duplicada.
Escrito a partir do README do projeto. Cada caso de uso é verificado com uma citação dele.
Como instalar o MCP llm-bus
Formatos verificados em 10 nov 2026Adicionar ao CursorAdicionar ao GooseInstalar o MCP llm-bus no Claude Code
$ claude mcp add --transport http llm-bus https://mcp.llm-bus.com/mcpInstalar o MCP llm-bus no Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"llm-bus": {
"url": "https://mcp.llm-bus.com/mcp"
}
}
}Instalar o MCP llm-bus no VS Code
.vscode/mcp.json
{
"servers": {
"llm-bus": {
"type": "http",
"url": "https://mcp.llm-bus.com/mcp"
}
}
}Instalar o MCP llm-bus no VS Code CLI
$ code --add-mcp '{"name":"llm-bus","type":"http","url":"https://mcp.llm-bus.com/mcp"}'Instalar o MCP llm-bus no Codex
$ codex mcp add llm-bus --url https://mcp.llm-bus.com/mcpInstalar o MCP llm-bus no Codex config.toml
~/.codex/config.toml
[mcp_servers.llm-bus] url = "https://mcp.llm-bus.com/mcp"
Instalar o MCP llm-bus no Gemini CLI
$ gemini mcp add -s user --transport http llm-bus https://mcp.llm-bus.com/mcpInstalar o MCP llm-bus no Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"llm-bus": {
"url": "https://mcp.llm-bus.com/mcp",
"type": "http"
}
}
}Configuração
DATABASE_URL
| Nome | Descrição | Tipo |
|---|---|---|
| DATABASE_URL | — |
Verificações automatizadas
Executado em 14 de nov. de 2026Relatório completo →Ainda não verificado. Um servidor precisa de uma pontuação de 80, nenhum problema grave e dados suficientes para verificarmos. Como as verificações funcionam · O que corrigir para ganhar mais pontos
- Repositório de origem vinculado e acessíveldanieldoderlein/llm-bus is public and reachablegithub.com/danieldoderlein/llm-bus ↗Passou
- O pacote indica este repositório como sua origemNão verificado
- Proveniência da build (atestação Sigstore)Não verificado
- Licença de código aberto (OSI)AGPL-3.0spdx.org/licenses/AGPL-3.0.html ↗Passou
- Commit ou release no último anoLast commit or release 2026-09-03github.com/danieldoderlein/llm-bus ↗Passou
- OpenSSF ScorecardNão verificado
- Nome do pacote não é próximo a um pacote popularNão verificado
- Nenhum aviso crítico no pacote ou em suas dependênciasNão verificado
- Sem instruções ocultas para o modelo0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPassou
- Ferramentas destrutivas estão rotuladasNão verificado
- O endpoint remoto responde ao handshake do MCPHTTPS endpoint answered 401 (sign-in required)Passou
README
Ver no 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).
Perguntas sobre o MCP llm-bus
Como adiciono o MCP llm-bus ao Claude Code?
Execute claude mcp add --transport http llm-bus https://mcp.llm-bus.com/mcp no seu terminal. Adicione --scope user para torná-lo disponível em todos os projetos.
Como adiciono o MCP llm-bus ao Cursor?
Abra ~/.cursor/mcp.json e adicione o servidor em mcpServers, usando a configuração do Cursor mostrada na seção de instalação acima.
Como eu evito que dois agentes editem o mesmo arquivo ao mesmo tempo?
O servidor fornece concessões consultivas (advisory leases) em arquivos reais para garantir que agentes em paralelo não sobrescrevam as edições uns dos outros.
Quais são os requisitos técnicos para self-hosting?
Para fazer o self-host, você precisa do Node versão 22 ou superior e PostgreSQL 16.
Existe uma maneira de evitar que os agentes fiquem consultando constantemente por novos trabalhos?
Sim, existe um canal de push via GET /api/wait que mantém uma requisição aberta até que haja trabalho disponível, evitando que agentes ociosos fiquem fazendo polling.