Eval-set leak tracing · contamination detection

Know whose copy
leaked.

Argos plants a unique canary in every recipient’s copy of your eval set, traces a leak to its source, and checks whether a model has seen it.

Request early accessSee how it works
1:1canary per recipient
0verdicts decided by AI
4/4demo fixes re-verified
2sample apps attack-tested
The eye is watching. Move your cursor, or click to make it blink.
Product tour · 30 seconds

See Argos in action

Turn protection on for a repo, open a pull request, and read the review.

Recorded from the Argos prototype. The interface text in the recording is in Korean.
The problem

Three ways a private
eval set goes wrong

Eval and data companies share hidden test sets with labs and vendors. Every copy is identical, so nobody can say where a leak came from.

No source

Leaked, and nobody knows whose copy

Access logs and contracts can’t tell you which recipient’s copy ended up outside.

Argos: a unique canary per recipientDeterministic match against a registry
Silent contamination

Scores quietly inflated

Nobody knows which models trained on the eval set. After-the-fact overlap checks miss cases.

Argos: query a model with the canariesStatistical, never a claim of “clean”
Found late

Leaks surface after the damage

At Appen, data was reportedly sold privately before it was published, with no prior disclosure.

Argos: scan for markers earlyPlanned · source: BleepingComputer
How it works

Issue it.
Trace it.
Probe it.

Issue unique copies

Hand over an eval file. Each recipient gets a copy carrying its own canary markers.

Trace the leak

Found part of the set outside? Match its markers against the registry to see whose copy it was.

Probe the model

Give a model a canary prefix and check whether it completes the unique suffix.

Issue
eval.jsonl
→ vendorA · vendorB · vendorC
3 unique copies
Trace
leaked.jsonl
→ markers match vendorB
registry evidence attached
Probe
model-A → likely seen
model-B → no match
a negative is not proof

Watch the leak get traced

An illustrative run of the flow we’re building.

$ argos canary issue --input eval.jsonl --recipients vendorA,vendorB,vendorC3 unique copies issued
$ argos canary scan leaked.jsonlsource: vendorB · markers matched · registry evidence
$ argos canary probe model-Acontinuation matches canary: likely seen
$ argos canary probe model-Bno match (not proof of no contamination)
0Copies issued
0/1Leak sources found
0/2Models flagged
↻ Replay

Illustrative. The model probe uses a mock model in our demo, and detection power on real models is not yet validated.

In your workflow

Argos reviews
every pull request

Findings land as a comment on the PR, ranked by severity, with a merge recommendation and a short lesson for whoever wrote the code.

A
argos-bot commented on this pull requestSecurity review

🟧 Argos Security Review

Highest severity HIGH · 2 findings · ❌ Recommend blocking merge
Result of a static, rule-based scan (no LLM used).
HighAPI1Object read or modified directly by an ID from the request parametersapp.mjs:45 · broken object-level authorization
HighAPI7Server makes a request to a user-supplied URL (SSRF)app.mjs:52 · server-side request forgery

🌱 What to learn from this change · API1

Authentication asks “who are you?”. Object authorization asks “are you allowed to access this data?”. A logged-in user must still not reach another person’s data.

Easy to miss: a login middleware or UUID ids don’t solve ownership. How guessable an ID is and who may access it are separate questions.

Think about it: users A and B are both logged in. What should happen when B requests A’s order ID? If the order isn’t shared by policy, the data must not be returned or changed. The server has to check the relationship between the authenticated user or tenant and the object.

Next time you review AI-written code:
  • Take the user identifier from the verified session, not the request body
  • Apply the ownership check to edits and deletes, not only reads
  • Test both together: your own request succeeds, someone else’s is refused
Severity-ranked findingsMerge recommendationTeaches while it blocks

Illustrative PR comment from the static pass. Dynamic attack-and-reproduce checks run separately, and only reproduced findings are reported as verified.

Three pillars

One story, told with evidence

Hand each recipient a distinct copy, protect the system that holds the copies, and know the answer when a leak or a suspect model turns up.

Building now

Leak tracing and contamination detection

The center of Argos. Per-recipient canaries, a registry, leak identification and model queries.

Verdicts from marker matches and statistics, never from AI
Node + Spring · verified on 2 sample apps

Access control proven by attack

Attack the system that stores and serves the copies, open a fix, and re-verify with the same attack. Runs in a disposable container.

Ownership, missing auth, SQL injection4/4 demo fixes re-verified on Node + sqlite · Spring now supported
Planned

Setup the AI does for you

Hand over a file instead of wiring specs, scenarios and environments. AI drafts the config for you to review.

We won’t promise “minutes” until we’ve measured it
Where we fit

Others test access.
We trace the leak.

Canary strings (practice)AI pentesting toolsSecure workspacesArgos
Per-recipient leak tracingPartial—PartialBuilding now
Model contamination detectionResearch stage——Building now
Access control proven by attack—Yes—Verified on demo
Works from a data fileResearch code——Planned

Based on public product descriptions; we haven’t verified competitor behavior. We found no commercial product offering per-recipient tracing plus contamination detection.

Honest by design

Evidence you can trust,
limits stated up front

What you get

  • The recipient behind a leaked copy, with registry evidence
  • A statistical check of whether a model reproduces your canaries
  • Your serving system attacked, with every fix re-verified
  • Confidence and limits shown next to every result

Our standard of proof

  • Built to trace and contain leaks, so you act on evidence fast
  • A match is evidence; a non-match is a signal, never a clean bill
  • Strongest on verbatim and near-verbatim copies, with heavy rewriting next on the roadmap
  • Evidence for your audits, not a certification. Node and Spring today, more stacks coming

Know before
it matters.
Let’s talk.

TeamSun · AI security
Mark · Full stack
Yerzhan · Business
Looking forEval teams to interview
Design partners
Move your cursor · click to burst