Independent agent assurance

Independent
agent assurance.

Zansn turns any agent run, on any framework, into portable, verifiable evidence and independent attestation that autonomous AI systems behaved within bounds, built to be trusted by the people who carry the risk.

Explore agent assuranceView research notes
Explore

Every run. Every trace. Every decision. Captured.

The independent assurance engine

What the assurance engine captures and produces

Agent trace spansReliability scoringFailure-mode taxonomyTool-call accuracyCost per runLatency profilesLocal vs cloud economicsPrivacy boundary mapsEgress violation checksReproducible evidence graphsBenchmark protocolsDeployment-readiness signals
The agent assurance gap

Most agent pilots never reach production, because no one can prove they behaved.

Organisations are moving from AI pilots to autonomous, tool-using agents, but the vast majority stall before production. The blocker is rarely model capability. It is that risk, audit, security, and insurance functions cannot get independent, verifiable evidence that an agent behaved within bounds, and no vendor can credibly grade its own agents. That gap is where Zansn lives.

01

Agent behaviour is non-deterministic

Systems that plan, call tools, retry, and delegate fail unpredictably under long-horizon and ambiguous workflows.

02

Tool calls create new failure paths

Every tool call, retry, and delegation introduces failure modes that generic application logs never capture.

03

Costs and latency compound

Multi-step and multi-model workflows have nonlinear token, runtime, and latency behaviour that must be measured.

04

Sensitive data changes the architecture

Private workflows cannot always send data to external model APIs during early experimentation.

05

Benchmark scores do not prove readiness

Standard model benchmarks do not predict how a system behaves in a real, tool-using, production workflow.

06

Evidence must precede decisions

Reliability, privacy, cost, and auditability need to be captured as evidence before deployment decisions scale.

Agent Trace
Streaming
1
Prompt
Input received
2
Planning
Decompose
3
Tool Call
Select & run
4
Tool Output
Collect
5
State Change
Update memory
6
Evaluation
Check & decide
7
Outcome
Respond / act
Tool error
timeout / 5xx
Retry
backoff & retry
Low confidence
needs review

swipe to follow the trace →

Trace Timeline0 - 20s
Agent run
Planning
Tool call
Tool output
Retry
Alt tool
Evaluation
Signalsidle
Latencyp95 8.2s
Error Rate12.4%
Retry Rate18.7%
Token Usage24.3K
Cost (est.)$0.142
Span
Event
Decision
Success
Warning
Error

Agentic systems fail across traces, tools, retries, and state changes. Zansn turns those events into observable evidence.

The Zansn assurance engine

One engine. Verifiable evidence that an agent behaved.

A local-first assurance engine that instruments any agent run and turns it into a portable, verifiable evidence record: reliability under repetition, tool-call behaviour, security and privacy boundaries, cost and latency, and a deployment-readiness signal. The evidence is designed to be checked independently, by the people who carry the risk, not taken on trust from the vendor whose agent is acting.

Assurance Engine
6 modules · live
Assurance Core
Evaluation Harness
20 runs
Agent TraceLayer
live
Cost &Latency Profiler
$0.14 / run
Privacy BoundaryTester
0 leaks
Evidence Graph
100% traced
Deployment Readiness
ready
stream[eval] reliability suite · 20 runs · pass_rate 0.95

Evaluation Harness

Tests model and workflow reliability against domain-specific benchmarks, with reliability targets, failure-mode capture, and repeatable, seeded test runs.

Outputs
reliability scorefailure taxonomyper-task variance
eval_harness.pypython
1from zansn.assure import Suite, Task, reliability
2 
3suite = Suite(
4    name="support-triage",
5    tasks=load_tasks("tasks/triage.jsonl"),
6    target=reliability(pass_rate=0.95, max_variance=0.03),
7    runs=20,              # repeated, seeded runs for variance
8)
9 
10report = suite.evaluate(
11    system=agent,
12    scorers=[exact_match, tool_call_valid, safe_refusal],
13)
14 
15report.assert_meets_target()          # fails the run if below target
16report.save("evidence/triage_eval.parquet")
Assurance Sprint

A focused technical engagement, not open-ended consulting.

A focused technical engagement for teams building AI agents or sensitive AI workflows. Zansn defines the evaluation protocol, instruments the workflow, runs repeated tests, captures failures, measures cost and latency, tests security and privacy boundaries, and delivers an evidence pack that can guide architecture, deployment, and further R&D.

Start an assurance sprint
Sprint outputs
  • 01Evaluation protocol
  • 02Benchmark suite
  • 03Agent trace map
  • 04Failure-mode taxonomy
  • 05Prompt injection and tool misuse tests
  • 06Privacy boundary report
  • 07Local/cloud cost and latency profile
  • 08Deployment-readiness evidence pack
Run it yourself

Watch an agent action become evidence.

Pick an action an AI agent might take, then run it through a live model of the assurance engine. Trace spans open, policies fire, sensitive fields are redacted, and a signed, reproducible evidence record is sealed with a readiness verdict. This runs entirely in your browser.

A support agent reads a customer case record to answer a billing question.

action.payloadtool.call
tool:"crm.lookup_case"
customer_name:"Dana Okafor"sensitive
email:"dana.okafor@example.com"sensitive
case_id:"CASE-40917"
medical_notes:"prescription refill pending"sensitive
assurance engine · live runready

Press Run assurance to stream the assurance-engine pipeline for this action.

Illustrative simulation of the assurance-engine pipeline. Runs locally, nothing leaves your browser.

What we measure

What gets measured before deployment.

Assurance is only as good as what it can measure. The assurance engine captures the signals that determine whether an autonomous workflow is ready for a real environment.

Reliability

07

Does it behave, run after run

  • Task reliability
  • Tool-call accuracy
  • Failure severity
  • Hallucination rate
  • Retry and recovery
  • Drift and degradation
  • Human escalation

Security

05

Whether it can be manipulated or misused

  • Prompt injection resistance
  • Excessive agency exposure
  • Permission boundary failures
  • Unsafe retries
  • Egress attempts

Cost & latency

04

What it costs to run at speed

  • Latency
  • Throughput
  • Token and runtime cost
  • GPU utilisation

Privacy & audit

03

What leaves the boundary, and can it be traced

  • Data exposure
  • Auditability
  • Reproducibility
Developer Starter Kit

Start measuring agent behaviour locally

zansn is a local-first npm package that turns any agent run into a portable evidence pack. It runs without a Zansn account and transmits nothing, the open-source entry point to independent agent assurance.

What each evidence pack captures
Task successAgent-aware tracesTool-call evidencePolicy & privacy findingsCost & latencyDeployment-readiness signals
View on npmFree, local, vendor-neutral, and independently verifiable today: every pack can be signed and checked offline with no Zansn account. The hosted evidence cloud is in progress; independent attestation comes later.
evaluate.tstypescript
1import { ZansnClient } from "zansn";
2 
3const zansn = new ZansnClient({
4  defaultPolicy: {
5    allowedTools: ["lookupCustomer"],
6    blockedTools: ["deleteCustomer"],
7    maxEstimatedCostUsd: 0.05,
8    maxLatencyMs: 5_000,
9  },
10});
11 
12// Run a task through the assurance harness and get back
13// a portable, reviewable evidence pack.
14const evidence = await zansn.runEvaluation({
15  projectId: "ZAN-RD-001",
16  tasks: [{ id: "support-001", expected: "active" }],
17  execute: myAgent,
18});
19 
20// readiness → "ready" | "review" | "blocked"
21console.log(evidence.summary.readiness);
Works with your agent stack

Assurance for agents you already build

Already building with a popular agent framework? Add one line and the run you already have becomes a portable evidence pack, with the same policy, privacy, cost, and readiness checks. One adapter per framework, all open source.

@zansn/ai-sdk
with-assurance.tstypescript
1import { generateText } from "ai";
2import { createZansnCollector } from "@zansn/ai-sdk";
3 
4const zansn = createZansnCollector({ projectId: "support-agent" });
5 
6const result = await generateText({
7  model,
8  prompt,
9  onStepFinish: zansn.onStepFinish, // capture the run
10});
11 
12const pack = await zansn.finalize({ output: result.text });
13// pack.summary.readiness → "ready" | "review" | "blocked"
Sovereign AI research infrastructure

Assurance you can trust must be provable on your own infrastructure.

You cannot prove you protect private data by sending it to someone else's cloud. Independent assurance has to be verifiable on controlled, high-performance infrastructure that the customer, and the assurance provider, actually own. That is why Zansn is building sovereign, local-first AI research infrastructure: a controlled, high-performance environment for developing and validating agent-assurance methods on real open-weight models and sensitive-data workloads, without depending on external model APIs.

Sovereign, controlled environment

A local, sovereign research environment where data, model weights, and results never have to leave a controlled boundary.

High-performance local compute

GPU-class infrastructure for running, quantising, and stress-testing open-weight models under real memory and latency constraints.

Reproducible local benchmarks

A controlled hardware and software environment for repeatable, independently checkable baselines.

Private-by-design experimentation

Test models on sensitive-data workflows with offline-capable, private inference, so privacy is architectural, not a promise.

Cost and inference frontier research

Measure local open-weight versus managed-cloud economics to define where each workload actually belongs.

Cloud-ready, not cloud-dependent

Cloud supports managed model comparison, collaboration, and scale, but the assurance itself is designed to hold up locally and sovereignly first.

Assurance Boundary
Exchange live
Local-First EnvironmentCloud-Ready Environment
Local Compute
Private Inference
Reproducible Tests
Secure Local Sandbox
Managed Model Services
Scalable Benchmarks
APIs
Observability Pipelines
Evidence packet
Validated output
Blocked content
Applied domain

Scientific and geospatial AI assurance.

Zansn's first applied domain program focuses on AI assurance for geospatial and environmental intelligence workflows, where robustness, uncertainty, data quality, and auditability determine whether AI outputs can support real-world decisions.

This is one applied domain, not the whole company. The same assurance engine applies to any autonomous or data-sensitive AI workflow.

Remote sensingEnvironmental monitoringAgricultureInfrastructure monitoringDisaster responseClimate and land-use workflows
Technical roadmap

From evidence engine to independent assurance standard.

Zansn's roadmap builds from measurement primitives, to a portable evidence format, to independent attestation, all developed on sovereign research infrastructure.

01Shipped

Assurance Engine

Reliability metrics, seeded runs, agent traces, security and privacy boundary tests, cost and latency, rolled into a readiness signal.

02Shipped

Verifiable Evidence Format

A signed, tamper-evident, openly published evidence format (zansn.signed-evidence-pack.v1, Ed25519), with a standalone zansn-verify CLI so any third party can check a record offline, no Zansn account required.

03Building

Evidence Cloud

Ingest, store, version, and export evidence across teams and runs, with audit- and insurer-ready records.

04Planned

Independent Attestation

Standards-mapped attestation an organisation can present to audit, security, procurement, and insurers, developed as genuine R&D.

05Planned

Sovereign Inference Frontier

Local open-weight versus managed-cloud economics, quantisation, and private inference, validated on Zansn's own high-performance research infrastructure.

Research tracks

The hard problems we research.

Independent agent assurance rests on genuinely unsolved technical problems. These are the research tracks where the outcome cannot be known in advance, stated as questions we run controlled experiments to answer.

Privacy-preserving verifiable evidence

Can an auditor or insurer verify that an agent behaved, and check the integrity of the record, without ever seeing the sensitive data behind it? Selective disclosure over signed evidence is an open problem.

Tamper-evident attestation

How do you produce an independent, cryptographically verifiable record of an autonomous action that holds up as evidence, without a trusted central party and without a public ledger?

Sovereign, local-first assurance

Which assurance methods can run entirely inside a customer's controlled, high-performance environment on open-weight models, and what is lost versus a cloud that sees everything?

Agent reliability under repetition

Measuring consistency, robustness, predictability, and safe failure behaviour in tool-using systems whose outputs are non-deterministic and whose regressions standard tests miss.

Adversarial testing of tool-using agents

Generating adversarial scenarios that expose unsafe or fraudulent agent actions current controls pass, and turning them into a repeatable benchmark.

Standards-body adoption of the evidence format

The signed, independently checkable evidence format (zansn.signed-evidence-pack.v1) already ships in the open-source zansn package. Whether it becomes the format auditors, insurers, and regulators adopt across frameworks, rather than a private convention, is the open question.

Research library

Technical notes and protocols.

A preview of the full research library: technical notes on agent reliability, observability, privacy boundaries, RAG evaluation, and evidence infrastructure. Each note states the question, method, limitations, and current maturity.

Open research library
Assurance method

From uncertainty to decision-quality evidence.

Zansn Labs studies AI systems as workflows, not demos. Each assurance cycle starts with a technical uncertainty, turns it into a testable hypothesis, runs controlled experiments, records failures, and produces evidence reviewed before deployment.

  1. 01Technical uncertainty
  2. 02Hypothesis
  3. 03Experiment
  4. 04Observation
  5. 05Evaluation
  6. 06Logical conclusion
  7. 07Documentation trail
Maps to recognised assurance frameworks
  • NIST AI RMFTrustworthy-AI risk functions
  • ISO/IEC 42001AI management system
  • EU AI ActHigh-risk AI obligations
  • OWASP Agentic Top 10Agentic AI security risks

Evidence packs are designed to map technical experiments to recognised AI assurance and risk-management practices, without claiming certification or approval.

Work with us

Have agents that need to prove they behaved?

Get in touch