Live demo · sample:agent_traces

Run it twice. The hash does not move.

800 agent runs, ranked by likelihood of failure. Free sample dataset, no signup, no quota. Every figure on this page came out of two runs made 33 seconds apart — and you can make a third.

reproduce this — credential-free

# no Authorization header — returns a test key, sample datasets only

$ curl -X POST https://hunter-seeker.io/api/v1/agents/register

$ pip install hunter-seeker

$ hs rank --dataset sample:agent_traces \

--entity run_id --outcome failed --reading trace@1

A test key resolves the free sample datasets only — enforced before any upload URL is minted or any byte is read. The blast radius of that key leaking is zero by construction, which is why this page can hand you one.

The determinism proof

Same decision, fresh receipt

Two runs on the same dataset, 33 seconds apart. Four hashes identical; the verdict id and the signature differ, because each receipt is issued at its own moment.

run A 02:22:27Z · run B 02:23:00Z

score_set_hash 1190bef2922e750a0ac8d77169c58a72 identical

spec_hash sp1_3043035b0b858e2fb352d76e72a71e14 identical

dataset_content_hash 001cf48de0c0c2edd3a4985fefb83612 identical

model_ref mr1_d48a6f743bd4d967da1167141316ec76 identical

core_hash 4d24e9fcfe4d6d42a4ece61ac02e72ef identical

differs — each receipt is issued at its own moment:

verdict_id 01M21ZJHSM8AVX3FEQVX4CDKT0

01M21ZKJ8BY5PF2DDZ2S2YQHEN

signature 805UGROle-Hpqiiiu10wx3Wu…

h5IYl3Ij-RMs6uNFC2qcfZA-…

The score set is the claim; the signature is the receipt. A matching score_set_hash across two runs is the whole determinism argument, and it is checkable by anyone who runs the same command.

Left channel · process

What the engine is doing, while it does it

A pending poll carries a stage, a completion fraction, and an append-only facts_so_far. These are counts and identities only — never a lift, a direction, or a rank order a later stage could reverse.

hs_poll_task — safe to show mid-run

stage: "profiling" frac: 0.05

row_count: 800

entity_identity: column:run_id

columns_quarantined: []

stage_history: ["profiling"]

reading trace@1 rows_in 800 → rows_out 800

groups_bound agent 4 · task 5 · tool 4

time_axis_parsed_as iso_offset

Nothing with a sign is streamed. Someone who sees a lift at six seconds and a refusal at fourteen will remember the lift — so the conclusion arrives once, whole, and only at the end.

Right channel · verdict

The conclusion, revealed once and whole

usability: actionable. The engine certified this run. Cleared the published lift bar at 4.102564 realised on every analysed row, with 4.285714 top-decile lift.

usability · actionable

gate · cleared

holdout · 480 / 160 / 160

provenance — every field on the signed Verdict

Engine version 0.3.6

Core hash 4d24e9fcfe4d6d42a4ece61ac02e72ef

Input hash 001cf48de0c0c2edd3a4985fefb83612

Spec hash sp1_3043035b0b858e2fb352d76e72a71e14

Analysis id sk1_8ee820f66815903fdf3c56a8fae50f97

Signing key 2026-q3

Public ledger hunter-seeker.io/.well-known/jwks.json

Verdict id 01M21ZJHSM8AVX3FEQVX4CDKT0

$ hs-verify verdict.json signature.json

→ valid

Verification is credential-free — Ed25519 over RFC 8785 canonical JSON, checked against the public key set. No account, and no call to us if you cache the keys.

The band boundary

The top of a list is not uniform

Scores on this run spread cleanly from 0.6947 down to 0.2651 — and the band changes partway down. Branch on the band, never on the score.

rows 1–46 · act · L3 · certified

row 47 down · escalate · L1 · uncertain

where the band turns

run_0287 0.694746 act L3 certified

run_0530 0.531973 act L3 certified

run_0049 0.515386 escalate L1 uncertain

run_0507 0.265143 escalate L1 uncertain

Sixteen thousandths of a point separate the last act row from the first escalate row. Anyone acting on "the top 100" of this ranking would action 54 rows the engine asked them to escalate.

Top factors, engine-authored and in engine order: different tool, higher agent_prior_n, lower input_tokens, higher tool_prior_outcome_rate. Three of the four are derived by the trace reading — they are not columns in the raw table.

What this run refuses

The same 800 rows, ranked raw, return nothing

Drop the trace reading and the engine declines: two viable features where it needs four. No ranking, no model_ref, no Verdict — and retry: "unproductive", which tells your retry loop to stop rather than spin.

The leak guard on the cleared run removed exactly one column — run_id, excluded as an identifier rather than flagged as leakage. An empty leak guard is not a clean bill of health, and the engine says so rather than implying otherwise.

Four more decisions, and what each one won't say

The pattern

Four conditions that only mean anything together

Pulled from the same analysis as the run above, at no extra cost. Read them as one combination — they were found together and only mean what they mean together.

hs_context_brief — free on the ranking_ref

tool is one of "browser"

agent_prior_n higher

input_tokens lower

tool_prior_outcome_rate higher

calibration error 0.054589

validation holdout · 480 train / 160 held out / 160 reserved

leak guard run_id [excluded] — identifier, not a predictor

usability actionable

Three of these four are derived by the trace reading rather than read from the table — agent_prior_n, tool_prior_outcome_rate and the prior rates behind them are computed over strictly earlier runs, so nothing from the future of a run informs its own score.

Association, not causation. Do not re-order them, do not rank one above another, and do not report any one of them on its own — the engine's own instruction, passed through verbatim.

Frequently asked questions

What is Hunter-Seeker?
Hunter-Seeker is a decision layer your AI agents call over MCP. It ranks a table by the likelihood of a yes/no outcome, scores single entities into act, escalate, or refuse, and signs every decision as an Ed25519 Verdict. The engine is deterministic — the same input produces the same output, byte for byte.
How is this different from letting the LLM decide?
An LLM authors a plausible-sounding number; Hunter-Seeker computes a calibrated one. Agents may generate copy — they may not invent the score. The engine validates on held-out data, refuses when the signal is too weak, and returns a signed Verdict, so the decision is evidence, not vibes.
What happens when the data can't support a decision?
The run comes back honest-empty: if nothing clears the lift bar, the engine refuses with structured reasons instead of returning weak rankings — and the run is refunded. A refuse band bills nothing. Refusing to guess is the feature, not a failure mode.
Do I need an account or an API key to try it?
No signup. Add the connector URL to Claude, ChatGPT, or Cursor — or run uvx hunter-seeker sample in a terminal. About sixty seconds later you have a signed Verdict on a free sample dataset. No email, no dashboard.
How do I verify a Verdict?
Any Verdict can be checked without credentials: call hs_verify_verdict over MCP, or verify offline with the open-source libraries hs-verify (pip) and @hunter-seeker/verify (npm) against the public keys at hunter-seeker.net/.well-known/jwks.json. Verification returns valid, invalid, expired, or unknown-key — nothing else, so the endpoint cannot be probed.

Give your agents a decision layer.

Add the connector, rank a table, and get back a band your agent can act on — signed, deterministic, and verifiable by anyone. No signup. Sixty seconds.
Start building
Start building