Quorum

Quorum spins up a swarm of AI agents that research, fact-check, and write — turning any question into a cited, publication-ready report in minutes.

Comment

Inspiration

Research is bottlenecked by serial work: search, read, verify, write — one step at a time, one person at a time. We wanted to see what happens when you treat research like a newsroom instead of a single analyst: multiple specialists working in parallel, coordinated by an editor, each accountable for their own claims.

Quorum is that idea built into a working pipeline. Give it a question — or a GitHub repo, or a local folder of code — and a swarm of coordinated AI agents decomposes it, researches it in parallel, fact-checks every claim against real sources, and writes it up as a structured, cited report.

What it does

Quorum takes a research query, a GitHub repository, or a local folder and runs it through five coordinated stages:

  1. Planning — an Orchestrator agent decomposes the input into an independent task DAG.
  2. Researching — multiple Researcher (or, for code, Document-Analysis) agents work sub-topics concurrently.
  3. Fact-checking — a Fact-Checker agent cross-verifies every claim against its actual source before it's allowed into the report.
  4. Writing — a Writer agent synthesizes verified findings into a structured, cited document.
  5. Delivery — available in-app, as Markdown, or as a publication-grade PDF via ReportLab.

For research queries, citations are real, verifiable DOIs. For codebases, citations are real files and line ranges from the actual repository — not academic references, because a codebase doesn't have any. You can run the whole pipeline against cloud providers with automatic fallback, or fully offline against a local Ollama model, with no data leaving your machine.

How we built it

  • Frontend: Next.js 14 (App Router), TypeScript, Tailwind CSS, shadcn/ui, Framer Motion for the live pipeline visualization, Zustand + TanStack Query for state, WebSocket for real-time agent status streaming.
  • Backend: FastAPI, an agent orchestration engine using a strategy pattern for swappable AI providers, a factory pattern for agent instantiation, and a DAG-based execution engine that runs independent tasks concurrently.
  • Reliability: every external AI call runs through a circuit breaker with exponential backoff and automatic provider fallback, so one provider outage doesn't take down a report mid-run.
  • Data: PostgreSQL with pgvector for source embeddings, Redis-backed task queue, ReportLab for PDF generation.

Challenges we ran into

The real one: our GitHub-repo and local-folder documentation mode was silently hallucinating entire reports. It looked fine on the surface — the pipeline ran, sections appeared, citations were present — but the citations were invented, because the mode was quietly falling through into our academic-research code path instead of running its own.

We traced it to a single mismatched dictionary key. Our document-analysis agent returned {"analysis": ..., "focus_area": ...}, but the downstream synthesis step was filtering for a "claims" key that only the research pipeline ever produces. That mismatch meant every document-analysis result was silently dropped before it reached the writer — the writer was being asked to produce 4–6 cited academic sections from an empty list, with only a repository name to go on. It had no way to do that honestly, so it didn't.

The fix wasn't just patching the key — it was rebuilding the doc-mode synthesis path to actually ground itself in the fetched repository content, replacing academic DOI citations with real file-and-line references, and adding a deterministic self-check pass that validates every cited file, class, and function name against what was actually fetched before the report is allowed to save.

What we learned

Multi-agent systems are easy to fake convincingly and easy to under-test as a result. A pipeline that visibly runs through five stages feels like proof of real work even when a silent data-shape mismatch has hollowed out the middle of it. The only real test is adversarial: compare outputs across runs, check whether every citation actually supports its claim, and specifically try to break the thing you're proudest of.

What's next for Quorum

  • Full MCP plugin support so third-party tools can register as additional agent roles
  • A CLI companion for deeper local/offline codebase analysis
  • Team workspaces and shared research libraries

Built With

Share this project:

Updates

Submission history