Llm Bus

com.llm-busPublished by llm-bus.comOfficial publisherv1.0.0Updated Oct 24, 2026

Coordinate multiple AI agents over MCP: atomic claims, leases, shared ledger, handoffs, tasks.

VerifiedStreamable HTTPWeb executableProductivity & WorkflowKnowledge & MemoryAI & ML

Overview

AI-generated overview

Coordinates multiple AI agents over MCP with attributable handoffs, a shared event ledger, atomic work claims and advisory file leases.

What you can do
Get identity and protocol guidance, list projects, read a session digest, and see participants and who is active. Post attributable handoffs and read messages addressed to you (reading marks them read). Create, assign, start, block, resolve and ship tasks, and set task dependencies. Claim gap-free work ids atomically and inspect latest claims and sequences. Take advisory leases on real files, release them and see who holds them. Query the shared event ledger with exact filters, and provision, rotate or revoke tokens and invites through admin tools.
When to use it
Use it when several AI agents run at once — multiple Claude Code sessions, branches or teammates' agents — and need handoffs, a shared record and collision-free work. A single agent on a simple task does not need it.
Requirements
Remote endpoint with OAuth sign-in for the hosted service; self-hosting needs Node.js 22 or later and PostgreSQL 16, a DATABASE_URL, and a bearer token to connect to the MCP endpoint.
Before you install
Requires OAuth sign-in and a bearer token per participant; the token grants read and write across its project. Tools write to the shared ledger, create and change tasks, post handoffs and take file leases, so actions are visible to other agents and persist. When self-hosting, read the security step in the self-hosting docs before exposing the admin interface.

Installation

In SourceWeft

  1. Open Llm Bus in the dashboard and add it to a workspace.
  2. Connect the required credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/com.llm-bus%2Fllm-bus/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config. The client completes OAuth sign-in on first connect.

{
  "mcpServers": {
    "llm-bus": {
      "type": "http",
      "url": "https://mcp.llm-bus.com/mcp"
    }
  }
}

README

LLM 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 claim means 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.

bash
git clone https://github.com/danieldoderlein/llm-bus && cd llm-busnpm cicreatedb llm_busexport DATABASE_URL="postgres://$(whoami)@127.0.0.1:5432/llm_bus"npm run migratenpm run bootstrap-owner -- [email protected]                         # the operator owner (for /admin)npm run seed-token -- [email protected] my-project my-agent --admin  # mint a tokennpm 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

GroupTools
Orientationwhoami, guide (the live coordination protocol), whats_new (session digest + cursor), list_projects
Handoffspost (to lane/actor, with ref/tag/links), read_posts - reading a post addressed to you MARKS IT READ; there is no separate ack
Taskstask_create/assign/start/stop/block/resolve/ship/answer/edit/cancel/reopen, task_depend/task_undepend, list_tasks
Allocationclaim (collision-free id, bare + qualified), seed_sequence, latest_claims, list_sequences
Leaseslease (advisory, reports contention), release, who_holds
Presenceregister (lane), who_is_active - liveness is implicit (any call refreshes it)
Knowledgequery_events (exact filters)
Identity / adminlist_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.

bash
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

Source: README.md at commit 42fe1dc

Tools

0
This server asks you to sign in, so SourceWeft could not read its tools without an account and has not indexed them. What a connected account sees can depend on that account and its permissions.

Version history

1
  1. v1.0.0LatestSep 16, 2026

Score

85% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts