Argus: Reviewing Defense Contracts in Hours, With Every Verdict Backed by Evidence

A defense procurement contract lands on your desk. It runs to hundreds of pages — schedules, exhibits, cross-references, clauses that modify other clauses. Somewhere inside it, a missing aggregate-liability cap, or a termination-for-convenience notice that runs a few days short of the contractual floor, can sink the deal in an audit. So someone reads all of it, line by line, against a long requirement checklist. And then comes the part nobody talks about: they have to prove every call they made.

That second job is the hard one. Reading is slow, but it's tractable. The trouble is that a verdict — this requirement is met, that one isn't — is worthless unless you can point to the exact passage that justifies it. An auditor doesn't want your conclusion. They want the clause.

Argus is a contract-intelligence proof-of-concept built around that exact problem: review the contract in hours instead of weeks, and ground every finding in the text it came from.

The work isn't reading. It's grounding.

Picture the shape of the job. On one side, a procurement contract of several hundred pages. On the other, a structured requirement checklist — in this engagement, 79 rows, each one a specific thing the contract must do: liability capped, confidentiality surviving termination, security controls fully mapped, delivery milestones inside the period of performance.

A human checks each row by hand, hunting through the document for the clause that satisfies it — or confirming, with confidence, that no such clause exists. It is slow, it is expensive, it is error-prone, and worst of all it is hard to defend later. Six weeks after the review, "I'm fairly sure I saw that somewhere in Exhibit B" is not an answer.

When Argus's own lab work dug into why this is hard, two findings stood out, and they shaped everything that came after:

• The number-one retrieval failure is a vocabulary gap. The legal language of a checklist rarely matches the engineering language of the contract. A row asks for "aggregate liability not to exceed the policy ceiling"; the contract buries the same idea in three sentences that never use the word "aggregate." Naive search walks straight past it.
• No single model finds all the clauses. In a controlled comparison on one deeply-audited checklist row, a smart multi-pass retrieval strategy located 12 of 15 verified clauses, while a single full-context read found only 6, and single-pass retrieval landed between 2 and 6. Different models miss different things.

And layered on top of all of it: this is defense work. Even the client's identity has to stay redacted. The hard technical problem comes wrapped in a non-negotiable confidentiality constraint.

A crew of governed agents, not one monolithic prompt

The instinct is to throw the whole contract and the whole checklist at one large model and ask it to grade. That fails for exactly the reasons above — one pass, one model, no grounding, no defensibility.

Argus does the opposite. It runs the review as a crew of governed agents, each with a narrow job, wired together so the output is auditable by construction:

• Smart multi-pass retrieval pulls the passages relevant to each checklist row — multiple passes precisely because the vocabulary gap means the first query rarely catches everything.
• A clause assembler gathers the retrieved passages into the candidate evidence for a given requirement.
• A panel of reviewer "judges" reaches consensus — three reviewers, by design, because no single model finds all the clauses. A 3/3 verdict and a 2/3 verdict are not the same thing, and the dossier records which it was.
• A gap-analysis roll-up turns the whole thing into a ledger: every row resolved to met, partial, or gap.

The spine that makes this trustworthy is a three-layer grounding discipline applied to every finding:

Requirement → Proof → Evidence. What the checklist demands, then the passage retrieved to satisfy it, then the exact (redacted) location where it lives.

Nothing is asserted. A verdict that can't walk back through those three layers doesn't get to be a verdict.

Pick a requirement below and watch it resolve. Each cell carries a status — green met, amber partial, red gap — and a click opens its grounding: the reviewer consensus, the confidence, and the redacted evidence location. The contract on the left and the gap ledger on the right are clickable too.

Everything in that view is synthetic and fully redacted — illustrative requirement IDs, section references rendered as §▆.▆, and a 61 met · 12 partial · 6 gap ledger that exists to show the shape of a review, not the result of a real one. No contract is read inside your browser; the figure is a diagram you can poke, with no network call and no model behind it.

The seam that graduates the crew onto Nexus

Here is the part that makes Argus the clearest "built-for-Nexus" story in the portfolio: the path isn't aspirational, it's already in the code.

Every model call in the review pipeline funnels through one provider-abstracted client — intelligence/llm_client.py. Today it routes across Anthropic, OpenAI, and Google behind a single Provider type. But its docstring states what it's really for, verbatim — it is

the migration seam between Sprint 1 (direct API calls) and Sprint 3+ (AGENTS / AaaS backend).

Its method signature is deliberately matched to llm_core.SLAgentsLLMBase.complete() — the entry point of Synaptix's internal Agents-as-a-Service engine, Nexus. Because the whole crew already talks only to this one seam, flipping the provider to "agents" graduates retrieval, assembly, the reviewer panel, and the roll-up onto Nexus AaaS without touching a single prompt. The decomposition Argus already has — retriever, assembler, judges, roll-up — is exactly the shape Agents-as-a-Service is built to host.

The fit goes deeper than plumbing. Argus's evidence discipline — Requirement → Proof → Evidence, multi-reviewer consensus, recorded confidence — mirrors the same governance doctrine the platform runs on: evidence required, no gate closes on assertion. On Nexus, that discipline stops being a project convention and becomes a runtime guarantee: one governed seam every call crosses, so the audit trail comes for free. And because the harness sits above the vendors, the review can run against a hosted frontier model or an open model inside a customer's perimeter — which is precisely what defense work demands.

To be exact about tense: this is the engineered destination, not a thing that is live today. The seam exists in the codebase; the migration is the Sprint 3 path. Argus does not "run on Nexus" right now — it is built to graduate onto it.

The payoff — and the honest status

Strip away the pitch and the outcome is concrete. Instead of weeks of line-by-line reading that's hard to defend, you get a review measured in hours where every requirement is checked against the actual text, every finding is grounded Requirement → Proof → Evidence, every verdict carries a reviewer consensus and a confidence, and the whole thing rolls up into a gap ledger an auditor can actually work from. The client's identity never has to appear for any of it to be useful — redaction is a property of the design, not a cleanup pass bolted on at the end.

Saying plainly where this isn't finished matters more than the pitch — and it's a locked decision, not a disclaimer:

• Argus is a Stage-2 proof-of-concept. It demonstrates the capability; it is not a shipped, validated product.
• Exactly one checklist row is human-audited — the "Audited Core," carried at high trust on a deep analysis where the Requirement/Proof/Evidence framework was validated across 15 verified clauses and 6 models. That one row is the proven floor.
• The 79-row LLM-generated gold set is marked known-defective — it cited the wrong primary clause in at least one case — which is why every dossier row carries an explicit data_quality flag of validated, generated, or not_run. Decision D-003 states it in four words: "demo dossier ≠ validated intelligence."

That honesty isn't a footnote to the product — it is the product. A contract reviewer you can trust is one that tells you, per row, how sure it is and why. The figures above are the same way: synthetic constants computed in your browser, labelled as such, with no client data anywhere near them.

Under the hood it's a Next.js front end on Vercel over a Python / FastAPI backend on Cloud Run with a ChromaDB vector index, all governed through Atlas PM as the control plane — where every state transition requires evidence. Boring on purpose. The interesting behavior lives in the crew and the grounding discipline; the seam is already cut for the day that crew moves onto Nexus.

---

SynaptixLabs · Argus — every verdict backed by evidence, the client redacted by design.