Akka Verify

Akka Verify is runtime-native evaluation, enforcement, evidence and governance for agents built on Akka or elsewhere. It lets you measure what an agent does against defined quality criteria, stop or redirect an action at runtime, and keep the record that an auditor asks for.

An agent that works in a demo is not yet one that customers and regulators can rely on. When evaluation, guardrails and governance are separate systems, nothing gives one view of what agents are doing, one way to stop them, or one record of why they acted. Akka Verify runs all three on the same runtime and the same ledger.

Evaluating agents

Evaluations measure an agent against defined quality criteria for its task, with deterministic evaluators and with a model acting as judge. They run in your tests before an agent is released, in batches against recorded traffic, and continuously on live traffic. Replay runs a new evaluator against past traffic by replaying the real execution. Adversarial tests attack your own agent with jailbreaks, prompt injection and known hazard categories, and report whether the agent resisted each attack.

See Evaluation, Evaluation in tests, Adversarial tests, Replaying recorded interactions and Evaluators.

Enforcing controls

A control is an obligation plus the mechanism that meets it. Every control is one of five control types:

Control type	What it does	Documentation
Guardrail	Blocks or passes an action at a runtime boundary: before a model call, before a tool call, or on the reply. Guardrails fail closed by default.	Guardrails, Classifiers
Sanitizer	Strips or masks content before it moves on: to a model, a tool or a log.	Data sanitization
Evaluation	Measures and scores behavior, live or in a test.	Evaluators, Model judges
Human	Gives a named person authority over a decision. The agent waits, durably, until the person decides.	Waiting for a person
Gate	Turns a check into a build or release decision.	Gates and reports, The coverage gate

Control type

What it does

Documentation

Guardrail

Blocks or passes an action at a runtime boundary: before a model call, before a tool call, or on the reply. Guardrails fail closed by default.

Guardrails, Classifiers

Sanitizer

Strips or masks content before it moves on: to a model, a tool or a log.

Data sanitization

Evaluation

Measures and scores behavior, live or in a test.

Evaluators, Model judges

Human

Gives a named person authority over a decision. The agent waits, durably, until the person decides.

Waiting for a person

Gate

Turns a check into a build or release decision.

Gates and reports, The coverage gate

An evaluation can observe after a run, or run inline as a guardrail that blocks, re-prompts or escalates before a response leaves the agent. Inline, the action, the verdict and the audit entry are committed in one transaction. A halt stops every in-flight and future model and tool call in its scope and moves the system to a safe state.

See Controls and Governance and the runtime.

Governing a system

Governance starts from risk. The risk envelope in the specification defines it, and a risk survey that asks questions about the system adds to it. Akka Verify derives the controls the system needs from that risk, grouped by the regulation, framework or corporate standard they come from. Controls derive differently in each jurisdiction. You accept, waive or reject each proposed control, and the accepted set becomes a signed bundle: a versioned set of controls that applies to one system.

At runtime, every control produces verdicts: upheld, breached, inconclusive or error. Akka Verify shows which controls are in force and whether each one held, the evidence behind every verdict, compliance over time, and drift in behavior or in verdicts. Changes to a system go through review with their evidence and approvals. Evidence packs collect signed evidence to hand to an auditor. Records are retained for the regulatory period and can be put on legal hold.

See From risk to controls.

The ledger

Every interaction is recorded in the ledger: non-sampled, hash-chained and tamper-evident. Each record carries the identity of the workload that acted, the trace it belongs to, and the controls that applied. Akka Verify reads the ledger for verdicts and evidence. Akka Optimize reads the same records to grade and train models.

See The ledger and evidence and Evaluators for writing to and reading from the ledger.

Agents built elsewhere

Agents that do not run on Akka send their traces over OpenTelemetry. For those agents, Akka Verify classifies the system against regulations and frameworks, derives and signs its controls, evaluates the captured traffic and seals the evidence. Inline guardrails, durable waits for a person, the authority behind each action, and the hash-chained ledger need the agent to run on the Akka runtime. See Agents built elsewhere.

Where it is in the documentation

Section	Start with
Getting started	Evaluate the planner agent
Concepts	Governance and the runtime, Controls, Evaluation, From risk to controls, The ledger and evidence
Developing	Guardrails, Classifiers, Evaluators, Data sanitization, Access Control Lists (ACLs)
Testing	Evaluation, Adversarial tests, Replaying recorded interactions
Reference	Auditors, Agentic AI safety exit conditions

Section

Start with

Getting started

Evaluate the planner agent

Concepts

Governance and the runtime, Controls, Evaluation, From risk to controls, The ledger and evidence

Developing

Guardrails, Classifiers, Evaluators, Data sanitization, Access Control Lists (ACLs)

Testing

Evaluation, Adversarial tests, Replaying recorded interactions

Reference

Auditors, Agentic AI safety exit conditions

Part of the Akka Agentic AI Platform

Akka SDK provides guardrails, sanitizers, evaluators and the ledger as components.
Akka Specify writes the risk envelope that the controls come from.
Akka Optimize holds a new model to the evidence that Akka Verify collects.
How Akka runs covers the runtime that enforces the controls.