Govern

Evidence

Measure what your agents actually did — and prove it.

Recursiv runs your agents, so it can measure everything they do. Evidence is the readout: the complete, scored record of what an agent or swarm produced — cost, accuracy, latency, the decision at every step, and where a human still belongs. It is legible to a business owner and exportable for an auditor.

Think of it as one instrument:

  • Inputs — the agents (and how they coordinate), the data they run on, and the evals that grade each output.
  • Run — execute the agent or swarm on a case, a batch, or ongoing live traffic.
  • Output — the Evidence: every step, every agent, graded, with cost and time.

There is no separate “simulate” mode. A test is a run scored against known answers; real work is a run that records live outcomes. Same engine, same evals.

Evals — the graders

An eval is a first-class scorer you attach to an agent or swarm (or a single step). It grades each output. Four types:

TypeWhat it doesNeeds a known answer?
codeA deterministic rule/assertion (“escalate anything over $500”). Free, instant.No
judgeAn LLM grades the output against a rubric. Use a different model family than the target to avoid self-preference.No
matchExact match against a known answer.Yes
consensusFan the case across several models; agreement = confidence, a split = a human belongs here. Premium (metered by the extra model calls).No

Because code, judge, and consensus need no answer key, they measure accuracy on real traffic, continuously.

Run a simulation

Give an agent or swarm a batch of cases, attach evals, and read the results — in one call. This is the whole loop.

1import { Recursiv } from '@recursiv/sdk';
2const r = new Recursiv();
3
4const { data } = await r.evidence.simulate({
5  target: { type: 'swarm', id: 'swarm_uuid' },
6  cases: [
7    { input: 'New account, $9.6k, multi-card order', expected: { answer: 'ESCALATE' } },
8    { input: 'Established customer, $120 order', expected: { answer: 'CLEAR' } },
9  ],
10  evals: [
11    { name: 'Follows escalation policy', type: 'judge', definition: { rubric: 'Does the decision follow the risk policy?' }, judge_model: 'anthropic/claude-sonnet-4.6' },
12  ],
13});
14
15console.log(data.run_id, data.run?.accuracy);
16for (const row of data.results) {
17  console.log(row.stepName, row.verdict, row.passed);
18}

Author a standing eval

Attach an eval so it grades every run of a target:

1await r.evidence.createEval({
2  target: { type: 'agent', id: 'agent_uuid' },
3  name: 'On-policy',
4  type: 'consensus',                    // cross-model agreement (premium)
5  definition: { models: ['google/gemini-3.5-flash', 'anthropic/claude-sonnet-4.6', 'openai/gpt-4o-mini'] },
6  threshold: 100,                       // full agreement = auto; a split flags a human
7});

Read the evidence

Every run is the per-case, per-agent, per-step matrix — plus accuracy, cost, and latency.

1const runs = await r.evidence.listRuns({ type: 'swarm', id: 'swarm_uuid' });
2const { data } = await r.evidence.getRun(runs.data[0].id);
3// data.run.accuracy, data.run.costMicrocents ; data.results = the matrix

You can also read it in the app (the Evidence tab on any agent or swarm), export it as CSV/JSON, or query the underlying tables over MCP.

From your agent (MCP)

A connected agent (Claude, Gemini, Cursor) can do all of this through MCP tools:

  • create_eval — author a scorer on an agent or swarm
  • run_evals — run a batch of cases and grade them (the whole loop in one call)
  • list_eval_runs — recent runs for a target
  • get_eval_run — one run’s full matrix

So you can just tell your agent: “break this process into a workflow, run 18 cases through it, and show me where a human belongs.”

What this proves

The same run produces the number an executive needs (is it working, what does it cost) and the record an auditor needs (every decision, attributable, exportable). That is the difference between asserting an agent behaved and being able to show it.