The decision layer for AI agents

Agents call it when they must decide: act, escalate, or refuse. Every decision comes back signed, and anyone can check it without an account.

Start building

CLI

MCP connector

Python

hunter-seeker — quickstart

copy

$ pip install hunter-seeker

$ curl -sX POST hunter-seeker.io/api/v1/agents/register

$ hs sample

# sample datasets are free — they never touch quota

Free. No signup. register returns a test key that reaches the six sample datasets and nothing else — safe to paste into a repo.

copy

# Claude · ChatGPT · Cursor — add as a connector

https://hunter-seeker.io/api/mcp

# then ask your agent:

"rank this table and act only where the Verdict says act"

✓no signup — sixty seconds to a signed Verdict

copy

# pip install hunter-seeker

run = hs_rank_topk(table, outcome="churned") # refunded if nothing clears the bar

v = hs_score_entity(run.model_ref, row) # band + reasons, signed

assert hs_verify_verdict(v.verdict, v.signature) == "valid"

Works where your agents work

MCP

REST

LangGraph

CrewAI

n8n

MCP

REST

LangGraph

CrewAI

n8n

The loop

Governed. Self-improving. Deterministic.

hs_rank_topk

hs_score_entity

hs_verify_verdict

act · escalate · refuse

report outcomes

action evidence

refit gate

never author a score · act to max_autonomy · verify before acting · humans only at escalate · report outcomes & attest

Verify

Don't trust this page. Check it.

Every decision returns a signed Verdict. Run the check yourself, with no server involved.

verify — offline

$pip install hs-verify

$hs-verify verdict.json signature.json

valid

invalid_signature

expired

unknown_key

Four possible answers, and nothing else, so the endpoint cannot be probed for anything it is not meant to tell you. Ed25519 detached JWS over RFC 8785 canonical JSON, checked against the public JWKS. Verification is credential-free over REST and offline in the open-source libraries. Keys rotate every 90 days; retired public keys stay published, so an old Verdict keeps verifying.

Usability

Every run says whether you may act on it

One field. An agent reads it and knows whether to proceed, without reconstructing the answer from four other fields.

usability — one field

usability: "actionable" the engine certified this run

usability: "unjudged" it could not apply its bar — an unanswered question, not a negative answer

usability: "refused" it applied the bar and nothing cleared

actionable

unjudged

refused

Read this before the rows. It travels on the portable brief too, so an analysis handed to a second agent carries its own caveat — the caveat is attached to the artifact, not to the conversation the artifact came from.

Benchmarks

What it does on data you can run yourself

Six hosted datasets, free, no quota. These are the numbers the engine returns today, not a leaderboard we built.

lift after the catalogue reading

returned honest-empty when ranked raw

Dataset	Rows	Question	Lift	Top-decile lift
sample:b2b_leads	800	Which leads convert?	7.3469	5.263158
sample:saas_churn	800	Which accounts churn?	4.4776	4.444444
sample:agent_traces	800	Which agent runs fail?	4.1026	4.285714
sample:telco_churn	800	Which accounts churn?	3.9216	6.190476
sample:sensor_stream	4,815	Which machines fail?	3.2448	7.518539
sample:usage_panel	9,600	Which accounts are declining?	2.5478	2.539683

Three of those return an honest non-finding when ranked raw and only clear once reduced with the right reading. That is in the table on purpose.

Rows	Seconds
25,000	7
100,000	60
250,000	140
1,000,000	2,404

Time to a decision, measured on a reference machine rather than production hardware — treat it as the shape of the cost, not an SLA. Roughly linear to 250k, then it steepens. A million-row ranking is a 40-minute job, not a slow request — submit it and poll.

The benchmark nobody else publishes: how often we refuse. That number goes here once there is enough production volume for it to mean something, and it goes here whatever it says.

Governance

Built to be audited by someone who does not trust you

Autonomy is granted per decision, not assumed. The whole ladder is published, including the rung that is not reachable.

Leakage is caught, and named

Any column whose values predict the outcome almost perfectly — univariate AUC above 0.98 — is quarantined, dropped, and returned with a plain-English reason. The lift bar does not catch leakage, because leaky features make lift look excellent. So the guard is separate, and a null leak_guard means no finding, not no leakage.

Autonomy is granted per decision

max_autonomy is a ceiling the engine sets for that one decision. Acting above it is a policy violation, not a judgement call.

Regulated use is decision-support only

Person-level outcomes in hiring, credit, education, insurance, benefits, justice, healthcare and immigration require acknowledge_decision_support: true and cap at L2. Social scoring, emotion recognition, and biometric categorisation framings are refused, with no acknowledgment path.

Nothing above the engine may author a number

Not the app, not an LLM, not your agent. It is enforced structurally — typed engine output, LLM steps with no write tools, a deterministic verifier — rather than by prompting. Agents may generate copy. They may not invent the score.

What we do not have yet: no SOC 2, no HIPAA attestation, no GDPR DPA. On a page that spends three sections on verifiability, an empty compliance badge row would be worse than saying so.

Every decision lands in a band: act, escalate, or refuse

Scoring is deterministic — the same input produces a byte-identical Verdict every run. Your agent acts on act, refuses on refuse, and pulls a human in only when the band says escalate.

# same input → same Verdict, every run

band act escalate refuse

score 0.91 autonomy L2 reasons 4

determinism byte-identical ✓

Signed Verdicts anyone can verify — without an account

Every Verdict carries an Ed25519 signature. Paste it at hunter-seeker.io/verify or check it in code with hs_verify_verdict — no key exchange, no account, no trust required.

// verdict.json

{ "band": "act", "score": 0.91,

"signature": "ed25519:8f3…" }

$ hs_verify_verdict → valid ✓ (keyless)

Honest-empty by construction

When the data doesn't clear the bar, Hunter-Seeker refuses to score — and the run is refunded. A refuse band bills nothing. That is the feature, not a failure mode.

// honest-empty result

{ "honest_empty": { "reasons":

["lift below 1.5 bar"] } }

billing run refunded ✓ — refuse bills nothing

Three calls to decide. Three more to improve.

Between the tools an agent has and the action it is about to take, one deterministic authority decides whether it may — and signs the answer.

hs_rank_topk

One run ranks your table against the outcome — refunded if nothing clears the bar.

run it twice

$hs rank --data sample:saas_churn > a.json

$hs rank --data sample:saas_churn > b.json

$diff a.json b.json

$ ← no output. that is the product.

hs_score_entity

Each entity gets a band, an autonomy ceiling, and reasons — signed as a Verdict.

hs_verify_verdict

Anyone checks the Ed25519 signature against the public JWKS — no account, no server, valid or not.

Recipes

One engine, many ways to use it

Four decisions on free sample datasets — what each run returns, and what the engine refuses to say about it.

See the four cases

sample:b2b_leads · 800 leads

An agent works the list, and only the rows it is allowed to work

Rank the leads, then let the agent act autonomously on the act band and hand the escalate band to a human. 5.263158 top-decile lift, calibration error 0.044679 — and the engine returns no next-best-action, because on this dataset it has evidence for none.

The pattern is four conditions together: a demo requested, first touch within 7 days, high page-view tier, and an industry that is not manufacturing or retail. 1.25% of leads match all four, at 7.346938775510204× lift.

sample:sensor_stream · 40 machines

Three bands at once, and an autonomy cap that follows them

Four signals every six hours for 30 days reduce to 1,160 daily snapshots with trailing 1/3/7-day windows. 7.518539 top-decile lift. Nine snapshots come back act at L3, about 68 escalate at L1, and 24 refuse at L0 — which caps that decision at observe-only.

The engine also flagged six of its own derived features as possible leakage, with single-feature AUCs from 0.86 to 0.97, and did not remove them. It hands you the number and the question rather than a clean-looking model.

sample:agent_traces · 800 runs

A fleet of agents that learns which of its own runs will fail

Ranked raw, the engine refuses: two viable features where it needs four. Add reading trace@1 and the same 800 rows clear at 4.285714 top-decile lift — because the reduction derives each run's prior failure rate over strictly earlier runs, which is not a column in the raw table.

Top factors, in engine order: different tool, higher agent_prior_n, lower input_tokens, higher tool_prior_outcome_rate. Run it twice and the score_set_hash does not move — see the live demo.

Read the deep pages first

Discover what we are building and how our vision is evolving

See the recipes

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