Every record and trace is immutable.
The trace is the runtime's own event-sourced record and tamper-evident. Nothing is serialized to a second system that could drop, reorder, or alter it. This lets you establish chain of custody for a regulator.
Off Akka
Evaluates a copy shipped over the wire.
On Akka
Evaluates the authoritative log itself.
Akka evaluates what the agent did.
Because evaluation runs in the same runtime, it sees the agent's full internal state, including the post-template prompt, tool arguments and results, retrieval chunks, model parameters, and the agent's own durable memory. It can check whether a response contradicts something the agent said earlier in the conversation, because it reads the same memory the agent does.
Off Akka
Sees only what the SDK instrumented and serialized.
On Akka
Nothing is dropped at the serialization boundary.
Evaluation can act in time to stop a response.
An evaluation can run passively, observing runs after they complete, or inline in the transactional path as an Akka guardrail. When it runs inline, a failing verdict can block, re-prompt, or escalate a response before it is emitted, and the action, its verdict, and the audit record commit together in a single transaction.
Off Akka
The verdict returns later, in another system.
On Akka
The verdict acts on the response as it happens.
Run tomorrow's guardrail against last quarter's real traffic.
Because the runtime is event-sourced, it can replay the true historical execution. You can run a new evaluator against past traffic and see exactly what it would have caught. After an incident, that lets you show a new control catches it.
Off Akka
Can only replay its copy of the spans.
On Akka
Replays the real execution, deterministically.
Govern the data without letting it leave.
Evaluation runs inside your own trust boundary, so your PII, prompts, and proprietary context are never sent to a third-party service to be judged. The data stays where the agent runs.
Off Akka
Sensitive data leaves the boundary to be evaluated.
On Akka
The data never crosses the boundary.
Every interaction is evaluated.
Evaluation shares the agent's actor compute instead of running on a separate ingestion tier, so every interaction can be evaluated by default. The same trace substrate also feeds Akka Optimize to lower the model bill.
Off Akka
Samples to control cost, so most traffic goes ungraded.
On Akka
Full coverage on shared compute.
The evaluator is governed too.
The evaluator itself runs in the same governed runtime, so its own behavior is traced, versioned, and audited by the same substrate. You can show which evaluator version judged which interaction.
Off Akka
The vendor's judge model cannot be inspected.
On Akka
The evaluator is on the record.