OmevraOmevra Omevra — all products

Omevra · Product five

Multi-Agent Evidence

A three-agent system for genetic-variant evidence work — Retriever, Synthesiser, Critic — measured head-to-head against the single-agent baseline it has to beat. Both systems scored at the benchmark’s ceiling — that is the finding.

The system, drawn

Build 1 (the Variant Evidence Agent) showed a single evidence agent can be held to a hard rule — cite, or decline — enforced in code. This project asks the follow-up question: does splitting the work across cooperating agents produce better evidence summaries than one model writing in one pass? Three agents, one guarantee layer, orchestrated as a LangGraph state graph:

RETRIEVERdeterministic — buildsthe evidence packetSYNTHESISERmodel — drafts citedclaims, or declinesCRITICmodel — checks every claimagainst the packetREVISErejected draft returnswith findings attachedFINALISEcode — gate enforced,uncited claims removedthe critic loop — at most 2 revisions, then finalise decidesan accepted draft skips REVISE and goes straight from CRITIC to FINALISE

The baseline it has to beat is the same model, the same packet, the same task text, in a single pass — no critic, no revision, no code guard. The packet for each variant was built once and given, identical, to both systems.

The measured comparison — both systems at the ceiling

The evaluation set is a fixed 36 variants: 12 that Build 1's gate summarises, 12 it declines, and 12 real ClinVar variants outside its universe entirely. Both systems are scored by a deterministic checker (does every stated value appear in the record it cites?) plus a manual rubric audit of all 96 claims against their cited records, on citation accuracy, evidence completeness, decline correctness, and cost and latency per variant.

1.00 vs 1.00Citation accuracy after the manual audit — 48 of 48 claims supported, both systems; 1.00 is this benchmark’s ceiling
36/36Decline correctness against the Build 1 gate — both systems, all 36 variants
2.7×The multi-agent system's token and latency cost to reach the same scores
36Fixed variants — 12 summarised, 12 declined, 12 outside the universe
MeasureSingle-agent baselineMulti-agent system
Citation accuracy (final, after manual audit of all 96 claims)48/48 = 1.0048/48 = 1.00
Citation accuracy (deterministic checker only)48/48 = 1.0046/48 = 0.96
Evidence completeness (mean, summaries)1.001.00
Decline correctness (vs the Build 1 gate)36/3636/36
Model calls3694
Tokens (prompt + completion)17,06246,225
Mean latency per variant1.40 s3.74 s
Estimated cost for the 36 variants$0.0096$0.0264

Tokens for the 36 variants

Single-agent baseline17,062 tokensMulti-agent system46,225 tokens

Mean latency per variant

Single-agent baseline1.40 sMulti-agent system3.74 s

The finding is a ceiling effect. On this evaluation the multi-agent system did not beat the baseline on any quality axis — citation accuracy, completeness and decline correctness are identical, both systems at 1.00, the ceiling of what this task, as specified, can measure. A benchmark both systems top out cannot separate them; a harder benchmark is needed. The multi-agent system also cost 2.7× the tokens and 2.7× the latency to get there. That is the result, and it stands.

The 0.96 note: the deterministic checker alone scores the multi-agent system 46/48 = 0.96. The two claims it fails restated a gene prior as a percentage (0.485 → “48.5%”, 0.542 → “54.2%”); the strict checker fails any value not literally in the record. The manual audit rules a fraction and its percentage the same quantity and reclassifies both as supported, which is why the audited figure is 1.00. The baseline never used the percentage form. Both numbers are reported, here and in the project's results.

The task is deliberately well-specified — a small structured packet, an explicit gate rule in the shared task text — and a single strong pass is already reliable in that regime. This evaluation does not show coordination is useless; it shows where its value does and does not appear at this scale. Where it appeared is the next section.

What the critic loop demonstrably did

The critic worked — it just had nothing left to fix in the final outputs. Across the 36 variants it ran 47 rounds and rejected drafts 16 times. Its rejections never changed a final verdict in this run, because finalise enforces the gate regardless — but the loop itself was exercised, counted, and caught real problems in process:

Failure modes — exercised, not described

ExerciseOutcome
FM1 — Conflicting records: one packet given its frozen ClinVar record (“Uncertain significance”, at the cutoff) and a live ClinVar record (“Likely benign”, evaluated later)No confusion, but no surfacing either. Zero cross-citation violations — no claim mixed the two statuses up. But the final summary never cited the live record at all: the conflict passed silently. Recorded as a design gap: the architecture has no step whose job is to raise a disagreement between frozen and live records; the critic only reviews claims that exist.
FM2 — Critic rejection loop: the Synthesiser sabotaged (exercise-only instruction) into adding an ACMG PS3 claim citing the AlphaMissense recordHandled by the loop. The critic rejected round 1 (unsupported), the revision removed the claim, round 2 accepted. PS3 is absent from the final output. This is the failure class the code guard cannot catch — the citation was real, the claim was not.
FM3 — Stale + duplicate evidence: the frozen ClinVar record duplicated (same id twice) plus a superseded older record (“Likely benign”) in one packetHandled. The final summary claimed the variant's status exactly once, citing the current frozen record; the stale record was never cited. Duplication cannot flip the gate: the gate also requires a model record, which duplicates do not create.
FM4 — Forced tool failure: live ClinVar and PubMed forced to raise for an out-of-universe variantHandled. The run completed and declined, and the outage is visible in the run's event log and the packet's error list. No exception escaped, and no record was fabricated to fill the gap.

The four exercises cost 10 model calls and 6,583 tokens; their full records ship in the project's eval/results/failure_modes.jsonl.

Two bugs this build found in itself — disclosed

What the whole build cost

All token counts are the API's own usage figures, summed per run — not estimates. Prices are the model's list prices and are labelled estimates wherever used. The evaluation itself (36 variants × 2 systems) used 63,287 tokens ≈ $0.036; the failure-mode exercises 6,583 tokens ≈ $0.004; development smoke tests and probes ≈ 7,400 tokens. The whole build: ≈ 77,000 tokens, ≈ $0.045 of API credit — the multi-agent system at $0.0264 against the baseline's $0.0096 for the same 36 variants.

Downloads

The project's own results document, byte-identical to the file in the project:

Limitations

Every figure on this page is taken from the project's RESULTS.md and its evaluation result files, and is cross-checked against both at build time.

Evaluations

The standalone proof page for this product: Evaluations — the protocol, the versioned results, and every result file as a download.