Quorum

io.github.terradev-cloudPublished by GitHub account terradev-cloudv0.1.1Updated Oct 25, 2026

Attested multi-agent consensus: proposals, votes, and outcomes stamped and traced.

VerifiedStreamable HTTPWeb executableProductivity & WorkflowKnowledge & Memory

Overview

AI-generated overview

A hosted MCP server for attested multi-agent consensus: open proposals, share a blackboard, vote with reasoning, and resolve outcomes with a social-choice rule.

What you can do
Open proposals with named options, expected voters, an aggregation algorithm, a deadline and a quorum threshold, and receive a proposal id and creation attestation. Append and read key-value entries on a proposal's shared blackboard, with ordered, attested history. Submit votes from expected voter identities with optional reasoning, under plurality, approval, borda, condorcet, opinion_pool or supermajority rules. Resolve the outcome once quorum is met or the deadline passes, returning co-winners when a result is genuinely ambiguous. Retrieve the full attested record of a proposal, filtered to writes, votes or outcome. Optionally bind a chosen api_key to a Telinea key so proposal telemetry is
When to use it
Use it when several agents or an orchestrator need to deliberate on a disputed question and you want a recorded, verifiable decision process rather than an ad-hoc majority vote. It suits decisions where the audit trail of who wrote what and who voted how matters.
Requirements
A remote streamable HTTP endpoint; no sign-in is required for anonymous use. Proposal telemetry to Telinea is optional and needs a one-time register call binding a chosen api_key to a Telinea key. Self-hosting requires Docker and configuration such as QUORUM_DATA_KEY and Telinea ingest settings.
Before you install
The register tool asks for a Telinea API key, which the server stores encrypted; treat both keys as secrets. Proposals, blackboard writes and votes are append-only and attested, so nothing can be edited or deleted afterwards. With telemetry enabled, proposal events are pushed to Telinea's ingest service.

Installation

In SourceWeft

  1. Open Quorum in the dashboard and add it to a workspace.
  2. 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/io.github.terradev-cloud%2Fquorum/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.

{
  "mcpServers": {
    "quorum": {
      "type": "http",
      "url": "https://quorum-mcp.terradev.cloud/mcp"
    }
  }
}

README

Quorum

Attested multi-agent consensus with a shared blackboard — an MCP server.

An orchestrator opens a proposal, participating agents write context to a shared blackboard and vote with reasoning, Quorum applies a principled aggregation algorithm from the social choice literature, and every step — proposal, writes, votes, outcome — is attested via Stamp and traced to Telinea. The record is immutable, tamper-evident, and independently verifiable.

Hosted endpoint (no sign-in, public): https://quorum-mcp.terradev.cloud/mcp

Why

Majority vote among LLM agents fails on disputed questions because agents trained on overlapping data share systematic blind spots — they are not the independent voters the Condorcet Jury Theorem requires. And when agents do decide together, the decision process — who voted, what they said, what context they worked from — is invisible.

Quorum is the complete primitive: algorithm plus state plus provenance.

Tools

  • register — one-time account setup: bind your api_key (a Quorum key you choose) to your telinea_key. The Telinea key is stored encrypted under a key derived from your Quorum key (AES-256-GCM, HKDF) — the Quorum key itself is never stored. Every span for your proposals is then pushed with your Telinea key, standard OTLP bearer auth.

  • propose — open a proposal: name (becomes the proposal id), question, voters (expected identities), deadline_minutes. Optional: api_key (from register — binds the proposal to your Telinea account for span streaming; omit for anonymous use), namespace (tenant prefix — the id becomes ns:name, so different teams can reuse names without colliding), options (default ["yes","no"]), algorithm (default approval), quorum (min % of voters, default 100), threshold (supermajority share, default 66.67), description. Returns the proposal id, creation attestation id, deadline, and blackboard URI.

  • write — append key/value to the proposal's blackboard, with optional author. Writes are appended, never replaced — the full ordered history is preserved and attested.

  • read — read the blackboard: every write in order with timestamp, author, and attestation id. Optional key filter. The deliberation record before voting.

  • vote — submit a ballot from an expected voter identity, with optional reasoning (stored in the attested record, never affects the outcome). Ballot shape depends on the algorithm — see below. Duplicate votes and post-deadline votes are rejected with structured errors.

  • resolve — apply the algorithm and attest the outcome. Callable once quorum is met (or after the deadline); also fires automatically when the deadline passes with quorum. Idempotent. Condorcet cycles and missed supermajority thresholds return co_winners with status unresolved — genuine ambiguity is surfaced, never hidden.

  • history — the complete attested record: creation, every write, every vote with reasoning, the outcome. Optional filter: all | writes | votes | outcome. The compliance artifact.

Algorithms

AlgorithmBallotUse when
pluralityoption stringBinary decisions only
approvaloption or list of optionsDefault. No strategic incentive; weak/multiple preferences
bordaranking of all options3–5 options; surfaces the broadly-acceptable choice
condorcetranking or single optionRational preference aggregation; cycles returned as co_winners
opinion_pool{option: probability} summing to 1Genuine probabilistic beliefs; returns full distribution
supermajorityoption stringHigh-stakes decisions needing >50% (set threshold)

The blackboard

LLM consensus failures are often information failures, not algorithm failures — agents vote in isolation. The blackboard is shared working memory scoped to one proposal: agents write analysis, read each other's findings, then vote informed. Write-first, read-second ordering and immutable pre-deadline votes are the conformity-bias defenses.

Tracing

Every proposal is one Telinea trace. The root span (proposal) opens at propose and closes at resolve or deadline expiry — its duration is the deliberation time. Each write, vote, and the resolution is a child span emitted in real time with its Stamp attestation id. Root status: OK decided, UNRESOLVED ambiguous, ERROR expired without quorum.

Span ids are deterministic (uuid5 over proposal id + event seq), so replays and restarts stay idempotent. Push is fire-and-forget and fail-safe — telemetry can never break a vote.

Auth is per-account: spans are pushed with the Telinea key registered via register, so ingest attributes them to the correct account. The key is stored encrypted (AES-256-GCM under HKDF of your Quorum key — never stored); a proposal-scoped re-encryption under the server-held QUORUM_DATA_KEY lets spans authenticate after restarts without re-presenting the Quorum key. A database dump exposes only ciphertext.

Config: TELINEA_INGEST_URL (default https://ingest.terradev.cloud/v1/traces), TELINEA_WORKSPACE_ID, TELINEA_PROJECT_ID, TELINEA_DISABLED=1, QUORUM_DATA_KEY, QUORUM_ACCOUNTS (account store path, default ~/.quorum/accounts.json).

HTTP transport

EndpointMethodDescription
/mcpPOSTJSON-RPC 2.0 — single or batch; notifications → 202
/mcpGETSSE keep-alive channel
/GET/POSTService identity / MCP alias
/healthGET{"status":"ok"}
/v1/infoGETSelf-describing service info (tools, auth, spans, docs)
/.well-known/agent.jsonGETAgent card
/.well-known/oauth-protected-resourceGETRFC 9728 — public, no auth

Concurrency capped at 100 simultaneous POST /mcp via asyncio.Semaphore.

Rate limiting is per-proposal: write and vote are capped at QUORUM_PROPOSAL_RATE events/min per proposal id (default 120), so one hot proposal can't starve the rest. The edge per-IP zone in Caddy is a coarse backstop only.

Attestation is queued and coalesced: concurrent events share one NTP sample per drain batch instead of one query per event — each event still gets its own Stamp record (unique id, own payload hash), so throughput isn't bound by NTP round-trips.

State

Event-sourced: one append-only JSONL file per proposal under ~/.quorum/proposals (override QUORUM_DATA_DIR). Namespaced proposals live in per-namespace subdirectories (proposals/<ns>/<name>.jsonl). The log is the history — history is a filtered read of the same file the tools append to. Nothing is rewritten or deleted.

Self-hosting

bash
git clone https://github.com/theoddden/quorum-mcp.gitcd quorum-mcpdocker compose up -d --build

Caddy handles TLS once DNS points at the host. See deploy/Caddyfile.

License

Copyright 2026 theoddden. Licensed under the Apache License, Version 2.0.

Source: README.md at commit dc67b56

Tools

7

register

OPTIONAL one-time setup -- only needed if you want proposal telemetry (OTLP spans) pushed to your Telinea account. Call once before propose: it binds an api_key you choose to your Telinea API key. Afterwards, pass the same api_key on propose and every span for that proposal is pushed to your Telinea with standard OTLP bearer auth. Storage: the Telinea key is sealed with AES-256-GCM under a key derived from your api_key (HKDF-SHA256, per-account salt); only sha256(api_key) is kept as the lookup id, so neither key is ever stored in the clear. Re-registering with the same api_key rotates the stored Telinea key. Skip this tool entirely for anonymous use -- propose works without an api_key, just with no span streaming.

Parametersapi_keyrequiredtelinea_keyrequired

propose

Open a new proposal: a question, named options, expected voter identities, an aggregation algorithm, a deadline, and a quorum threshold. Returns the proposal id, the creation attestation, and the deadline. All later operations key off the proposal id.

Parametersnamerequiredquorumvotersrequiredapi_keyoptionsquestionrequiredalgorithmnamespacethresholddescriptiondeadline_minutesrequired

write

Append a key-value entry to a proposal's blackboard. Any agent may write; writes are appended, never replaced -- the full ordered history is preserved and attested.

Parameterskeyrequiredvaluerequiredauthorproposal_idrequired

read

Read a proposal's blackboard: every write in order with timestamp, author, and attestation id -- the complete deliberation record, or filtered to one key.

Parameterskeyproposal_idrequired

vote

Submit a vote from an expected voter identity, with optional reasoning stored in the attested record. Vote shape depends on the algorithm: plurality/supermajority take an option string; approval takes an option or list of options; borda takes a ranking of all options; condorcet takes a ranking or a single option; opinion_pool takes a probability distribution over options. Duplicates and post-deadline votes are rejected.

Parametersvaluerequiredvoterrequiredreasoningproposal_idrequired

resolve

Compute and attest the outcome once quorum is met (or the deadline has passed). Idempotent: resolving twice returns the recorded outcome. Condorcet cycles and missed supermajority thresholds return co_winners with status unresolved rather than an arbitrary tiebreak.

Parametersproposal_idrequired

history

The complete attested record of a proposal in chronological order: creation, every blackboard write, every vote with reasoning, the outcome. Optional filter: all | writes | votes | outcome.

Parametersfilterproposal_idrequired

Version history

1
  1. v0.1.1LatestSep 27, 2026

Score

90% 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 listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

    Declare a license in the repository or the registry entry.