# Delibera: LLM model debates with a chairman's verdict Delibera is an open source .NET 10 framework: models discuss a question in rounds, a chairman issues the verdict, and the transcript stays with you. RAG, MCP, SSE, MIT. > For the index of this section of the site, see [llms.txt](https://anetlab.com/llms.txt) betav10.5.3License: MIT[Documentation](https://techbuzzz.github.io/Delibera/)[Repository](https://github.com/techbuzzz/Delibera) # Delibera A debate instead of a single answer: the verdict and the full transcript One model is a single point of failure: a plausible wrong answer is hard to tell from a well-reasoned one. Delibera works the question across models, issues a verdict and keeps the full transcript. ## What it is Delibera is a framework for collective decision making. Several models discuss the question in rounds, critique each other’s answers, and a chairman weighs the arguments and records the verdict. What comes out is the verdict and the full transcript of the discussion. It works as a .NET library and as a server with REST, SSE and MCP. Where the product stops: Delibera is not a source of truth. It does not verify facts and it does not answer for the correctness of the verdict — it structures the discussion and leaves a trail. It does not take over agent orchestration either: choosing models, tools and memory stays on the integrator’s side. ## Who it is for Teams who need a decision they can look at, not an opinion a model produced. One model on a hard question is a single point of failure. It tends to give a confident and plausible answer, and telling a well-founded conclusion from a well-sounding wrong one is close to impossible: there is no reasoning to inspect. When the decision goes into a release, a contract, a risk checklist or an acceptance review, what you need is the trail — who said what, why it ended up that way and who owns the call. Delibera gives you four things: * **Several independent readings.** The models see the task differently, and the disagreement shows up immediately — that is the thing worth discussing. * **A checkable trail.** The transcript and the verdict are artifacts: you can read them, challenge them and attach them to the decision. * **A repeatable process.** A debate is not an argument you stage by hand, but a template with roles, rounds and a chairman. The same question is worked the same way every time. * **Your own perimeter.** Self-hosted, MIT, a library and a server on .NET — the answer never leaves your network. ## How it works graph TD Q\[Question\] --> C\[Chairman\] C --> P\[Participants\] P --> X\[Critique\] X --> C C --> V\[Verdict\] K\[Knowledge\] --> P O\[Operator\] -.-> P classDef accent fill:#eef7f0,stroke:#008A2A,stroke-width:1.5px,color:#141616 classDef muted fill:#f7f8f8,stroke:#c8cdcd,stroke-width:1px,color:#505757 class C,V accent class K,O muted Diagram 01How a debate runs The path of a question: question → the chairman opens the discussion → a round of parallel participant answers → critique of each other’s answers → the next round → verdict and transcript. The Knowledge Keeper is attached when RAG is on and the request names a corpus. The Operator is a library-level role and is not attached through the server API; its branch is dashed in the diagram. Participants in one round answer in parallel, and the round lasts as long as its slowest member. A failed member is excluded from the round instead of being spliced into the transcript as `[ERROR: ...]` for the chairman to read as an opinion. The Knowledge Keeper pulls context from the corpus during the debate and answers with citations. At library level the Operator is a micro-agent that calls MCP tools while the discussion is running. ## What it covers | | Value | | --- | --- | | Input | A question or one of the five built-in debate templates; a document corpus for RAG | | Output | Rounds with participant answers, the verdict, token statistics, Markdown export of the transcript | | Transport | REST and MCP in `Delibera.Server`, an SSE stream of rounds, gRPC services `DebateService` / `ScenarioService` / `CorpusService` | | Deployment | .NET 10, Docker Compose, Qdrant or PostgreSQL/pgvector, Redis if you want it, Ollama or any OpenAI-compatible provider | The debate templates are ready-made decision scenarios rather than an abstraction: | Template | Rounds | Where it applies | | --- | --- | --- | | `code-review` | 4 | Code review: several models look for defects in a diff | | `risk-committee` | 5 | Risk and compliance: a committee weighs the risk and decides | | `requirements-review` | 4 | Requirements: contradictions and gaps in the specification | | `legal-contract-review` | 4 | Legal review of a contract | | `architecture-decision` | 4 | An architecture decision with the options worked through | A template is a set of roles and a round strategy, not a prompt text: a custom scenario is an `IServerTemplate` implementation registered in DI. ## Where it fits * **Reviewing changes.** A diff goes into a debate, and what comes out is the findings of several independent reviewers plus a synthesised verdict. * **Risk and compliance.** A risk decision is made against a committee template, with the protocol kept in the transcript. * **Working through requirements.** Contradictions in a specification are found not by one person, but by several models with different emphases. * **Architecture forks.** The options are compared in one format, and the decision stays in your repository. ## What is measured The measurements were taken on 6 October 2026 against Ollama Cloud with real keys and are published in the project documentation. | Scenario | Time | Surface | What it is | | --- | --- | --- | --- | | code-review, 3 participants and a chairman, 4 rounds | 69.8 s | library | a quality run | | architecture, same composition | 119.0 s | library | a quality run | | contested, same composition | 238.5 s | library | a quality run | | 5 topics × {2, 4} rounds × {compression on, off} | 32.6 s average | library | 20 runs for $0.12 | | retry-policy, cancellation, latency-slo with RAG | 208.7 / 172.9 / 154.3 s | library | debates with Knowledge Keeper and Operator | | Completed debates over HTTP, n=8 | 125,308 – 601,903 ms | server | server records | | Server control loop | 36–321 ms | server | health, templates, corpus, MCP | The measurements sit on two surfaces, and for an IT Pro that matters more than the numbers themselves. **Library** — a debate inside the process: no HTTP, no authentication, no gateway, the same numbers an integrator will see in their own tests. **Server** — `Delibera.Server` in a container: job intake, SSE and HTTP are added, so the upper bound runs past 600 s while the library stays within 238 s. The row with Knowledge Keeper and Operator is a library one: the Operator is not connected through the server API, in the harness its role was wired directly. The main thing these numbers say: the framework itself is not the bottleneck. Explanation time takes not a second — 0.0 s in every run — and throughput holds at 840–1,144 characters per second. The time is determined by how much text the models write. Critique and refinement take 62–77% of every debate, because both rounds carry the accumulated transcript in the prompt. Two numbers that must not be mixed with the rest. **Context compression measured 11.7–12.1%.** Until v10.5.0 the documentation advertised 30–70% savings; the measured `HybridCompressor` yield is about 40% of the former lower bound of 30% — roughly six times below the upper 70%. The README and the docs now carry the measured 11.7–12.1% and state outright that the old figure was never measured and that v10.5.0 corrected it. The measured number is the one stated here. **6 ms versus 2699 ms is an abort latency, not a benchmark.** The Web UI proxy aborts the upstream SSE on client disconnect in 6 ms instead of 2699 ms. The metric answers “how fast does the stream break”, and has nothing to do with the performance of a debate. ## Cases Delibera is open source: the code, the documentation and the measurements are available, and the product can be deployed and checked on your own data. The case in the [Portfolio](https://anetlab.com/projects.md#delibera) is the product itself. We have no confirmed production deployments with a measured effect, and we will not cite ones that do not exist. What you can check today: 620 .NET tests (493 Core, 117 Server, 10 gRPC) and 34 Web UI tests, the published measurements, five ready templates and an API you call from your own code. ## Honest limits * **The HTTP server has no authentication and no throttling.** Anyone who knows the address can start paid debates. Limits exist at library level — `WithRateLimit(n, window)`, `WithCostLimit(decimal, CostLimitBehavior)`, `WithTokenBudget(long)` — and they do not stand in for authentication. When a limit denies a debate you get a degraded result carrying the spend, not an exception: a ceiling that throws leaves no record of what was already spent. * **Published ports listen on 127.0.0.1 only.** That is the enforcement, not decoration: do not expose the port until an authenticating reverse proxy sits in front of the server. The “Run with Docker Compose” section in `docs/Server.md` points at `docker-compose.server.yml`, a file that does not exist in the repository, so the command cannot run. The example it prints publishes `ports: ["8080:8080"]` along with the provider port `11434`: build a compose file from that example and both the server without authentication and the model provider reach the network. * **Distributed turn-level execution is a placeholder.** `DebateWorkerService` stays a no-op and the debate still runs in the process that accepted it. Redis gives shared state and round events, but not horizontal scaling. * **The Operator is not reachable through the server API** — see “How it works”. * **Verdict quality is measured by nothing.** The product claims no “better quality” percentages. In one measurement a verdict invented a unanimity that the transcript did not contain; such cases are caught by reading the transcript, not by a counter. * **CORS is off by default** and is enabled with an exact list of origins; there is no wildcard switch. * **Completed debate records are evicted over time.** The median of the sample changes with every debate added, so only the range and the per-template split are stable statements. * **A debate spends real LLM credits.** The integrator sets the budget. ## How to start ``` dotnet add package Delibera.Core # the library — start here dotnet add package Delibera.Server # ASP.NET Core host: Minimal API, SSE, MCP dotnet add package Delibera.Redis # Redis orchestrator and shared result cache ``` Or containers with a pinned version: ``` curl -O https://raw.githubusercontent.com/techbuzzz/Delibera/main/deploy/docker-compose.hub.yml export DELIBERA_VERSION=10.5.3 docker compose -f docker-compose.hub.yml up -d ``` Three things integrators trip over. Templates pick their participants by two separate keys — `Delibera:Models:Fast` and `Delibera:Models:Strong` — and not by `Delibera:Providers:DefaultModel`. Setting only the provider is not enough: the server starts healthy and answers the first debate with HTTP 500. `maxRounds` at the top level of the request is silently ignored — the override lives in the nested `options.maxRounds`. The extra key is not an error, it simply does not apply, and the template falls back to its `DefaultMaxRounds` = 4. SSE delivers two different shapes. A subscription opened before the debate ends gives one frame per completed round plus heartbeats; one opened afterwards gives a single frame with all the rounds at once. The shapes are not interchangeable: to watch progress, subscribe before the finish. ## Status and license Delibera ships releases: version 10.5.3 of 11 October 2026 is published on NuGet (`Delibera.Core`, `Delibera.Server`, `Delibera.Redis`) and on Docker for amd64 and arm64. Coverage as measured in release 10.5.2 is 620 .NET tests and 34 Web UI tests, all passing. The status is beta rather than GA for three reasons: the server surface is exposed without authentication, distributed turn-level execution is still a placeholder, and verdict quality is measured by nothing. All three are listed under limitations rather than hidden. The license is MIT: use, modify and redistribute freely, including commercially. ## Related materials * [The Delibera case in the Portfolio](https://anetlab.com/projects.md#delibera) * [MCP for enterprise: protocol, security and boundaries](https://anetlab.com/blog/mcp-for-enterprise.md) * [Agentic workflows in enterprise: patterns and anti-patterns](https://anetlab.com/blog/agentic-workflows-enterprise.md) * [RAG on .NET: an architecture that survives production](https://anetlab.com/blog/rag-na-dotnet.md) * [Building a RAG pipeline on .NET: a practical walkthrough](https://anetlab.com/blog/rag-pipeline-dotnet.md) ## CTA Where one model’s answer is not enough, [get in touch](https://anetlab.com/contact.md). We can look at which of the five built-in debate templates fits your task, which limitations matter for your setup and how Delibera sits next to your agent orchestration. FAQ ## Frequently asked questions Do we need our own infrastructure?+ Not as a requirement. It is a .NET 10 library, and the server is optional. For the full set you need Docker, a vector store (Qdrant or PostgreSQL/pgvector) and any OpenAI-compatible provider. Redis adds a shared result cache and round events, but not horizontal scaling. Can we run it ourselves?+ Yes, the product is self-hosted under MIT: the code, the documentation and the measurements are open. The server port listens on 127.0.0.1 only and the HTTP server has no authentication, so it can only be exposed behind your own authenticating proxy. What does one debate cost?+ A debate spends real LLM credits, and the integrator sets the budget. Limits exist at library level — WithRateLimit(n, window), WithCostLimit(decimal, CostLimitBehavior), WithTokenBudget(long). When a limit denies a debate you get a degraded result carrying the spend, not an exception. Which models work?+ Any OpenAI-compatible provider — Ollama, YandexGPT, OpenAI. The template sets the participants, the round strategy and the number of rounds; five templates are built in. What happens if a model fails?+ The member is excluded from the round instead of being spliced into the transcript as \[ERROR: ...\] for the chairman to read as an opinion. Degradation is reported by FailedMembers and IsDegraded. Who owns the quality of the verdict?+ Nobody: the product measures no verdict quality and claims no "better quality" percentages. In one measurement a verdict invented a unanimity that the transcript did not contain — such cases are caught by reading the transcript, not by a counter.