# Tyr Auditor
Tyr is the evidence auditor for Valdr agent sessions.

Use Tyr when you need to evaluate how an agent run performed, not just whether the final code or document looks acceptable. Tyr v2 fetches session context, pages the event stream, applies a seven-dimension rubric, and persists a score run with evidence.

The launch handle is `tyr-v2`.

Two agent runs can produce the same output. One followed instructions, validated assumptions, handled tool failures correctly, and documented evidence. The other got lucky.

Tyr exists to tell the difference. It measures execution quality because reliable agent systems improve from evidence, not from assuming a good-looking output means the run was good.

Tyr answers one question: "What does the session evidence prove about this agent run?"

## What this page covers

- When Tyr is the right audit agent
- Why execution quality matters even when the output looks correct
- How Tyr differs from Sigrid review
- How to use Tyr from the UI and CLI
- What Tyr should not be asked to do
- How the Tyr v2 auditor is assembled inside the pack

## When you're new to Valdr

Start with Tyr when:

- An important agent session needs a durable quality score
- You need evidence about prompt adherence, tool usage, and execution process
- You want to compare agent runs over time
- You need to know whether required validation was actually attempted
- You want audit findings stored as part of Valdr history

Think of Tyr as the session evidence auditor. It does not replace task review. It evaluates how the run behaved.

## Use Tyr when

| Need | Ask Tyr to |
|------|------------|
| Session evaluation | Audit a specific session or latest executor session for a task |
| Evidence review | Page session events and cite evidence from the run |
| Prompt integrity | Compare declared capabilities and prompt evidence when scoring behavior |
| Tooling compliance | Check whether the agent used required tools and handled failures correctly |
| Durable scoring | Persist a score run with verdict, dimensions, findings, criteria, and confidence |

Tyr is audit-focused. It should not be used as a code reviewer or implementation agent. Use Sigrid to decide whether task work is acceptable; use Tyr to evaluate the quality of the agent run.

## First five minutes with Tyr

A first Tyr session should feel like turning a transcript into structured evidence:

| You ask | Tyr helps by |
|---------|--------------|
| "Audit the latest executor session for WEB-142." | Resolving the session and fetching compact audit context |
| "Did the agent follow required validation?" | Searching event evidence for commands, failures, and final claims |
| "Why did this run score low?" | Explaining findings across the scoring dimensions |
| "Record the audit." | Submitting the score payload and returning a stored run receipt when available |

The core value is evidence-backed confidence. Tyr should fail closed when claims cannot be verified from session evidence.

## How to use Tyr

{{% steps %}}

### Start with a session or task

Open an [Agent Sessions](/valdr/docs/ui/agent-sessions/) view when you want to inspect a run visually, or launch an auditor session with handle `tyr-v2`. Give Tyr the session ULID, task key, or latest-session target.

From Claude Code or Codex CLI, use the [`valdr-auditor`](/valdr/docs/skills/valdr-auditor/) wrapper and name the handle:

```text
/valdr-auditor
Use tyr-v2 to audit the latest executor session for WEB-142 and record a score run.
```

### Fetch compact audit context

Tyr starts with compact session metadata, prompt and capability snapshots, and the score payload template. This keeps the audit grounded in the actual run.

### Page the event stream

Tyr pages session events before scoring. It should not score from memory, vibes, or a partial transcript when more evidence is available.

### Apply the rubric

Tyr evaluates the run across instructions adherence, prompt integrity, tooling compliance, task correctness, risk and safety, execution quality, and task quality.

### Persist the score

Tyr submits the score payload through the audit workflow, then reports the verdict, score, top findings, and stored run identifier when returned.

{{% /steps %}}

## Which workflow agent should I use?

| Need | Start with |
|------|------------|
| Turn a rough idea into a plan and tasks | **Freya** |
| Review a completed task implementation | **Sigrid** |
| Score how an agent session performed | **Tyr** |
| Coordinate sprint execution and reviewer routing | **Skadi** |

Tyr is the right agent when the question is about the run, not just the output. Use Sigrid for task acceptance and Tyr for session reliability.

## Strong prompts

Use Tyr for audit requests tied to session evidence:

- "Use `tyr-v2` to audit the latest executor session for task `WEB-142`."
- "Audit session `01JX8Y6J9J3M6P4T4Y6R8ABCDE` and record a score run."
- "Check whether this run followed its required validation steps."
- "Score the session with attention to tooling compliance and task correctness."
- "Summarize the top findings after the score is stored."

The best Tyr prompts name the session or task. If you care about a specific dimension, name it directly.

## Typical workflow

1. Give Tyr the session or task to audit.
2. Let Tyr fetch compact audit context.
3. Let Tyr page session events and gather evidence.
4. Let Tyr hot-load scoring contract guidance when needed.
5. Persist the score run.
6. Use the verdict and findings to improve prompts, tools, task quality, or execution workflows.

Tyr makes session quality durable. Execution quality compounds when each scored run teaches you which prompts, tools, tasks, and workflows are reliable.

## How Tyr is built (advanced)

The pack defines Tyr v2 with a mandatory score-audit workflow and validation capabilities:

| Capability | Role | Use |
|------------|------|-----|
| `valdr.auditor.tyr.v2.system` | Core | Audit identity, context/events/score workflow, pagination rules, dimensions, and hard rules |
| `valdr.auditor.tyr.v2.payload-contract` | Constraints | Canonical score payload shape and required fields |
| `valdr.auditor.tyr.v2.prompt-integrity` | Validation | Declared capabilities, prompt evidence, and drift checks |
| `valdr.auditor.tyr.v2.tooling` | Validation | Required tool use, policy adherence, and failure handling |
| `valdr.auditor.tyr.v2.task-correctness` | Validation | Acceptance criteria verdicts with evidence |
| `valdr.auditor.tyr.v2.execution-quality` | Validation | Planning, verification, reporting, and process quality |

You do not need these capability keys to use Tyr. They matter when you want to understand why Tyr requires event evidence, canonical payload fields, and the `tyr-v2` auditor handle.

## What Tyr should not do

Tyr is not the task reviewer and should not score from vibes. Do not use it to review code style, implement fixes, or invent evidence when the transcript does not prove a claim.

| Instead of asking Tyr to... | Ask Tyr to... |
|-----------------------------|---------------|
| "Review this code for style." | "Ask Sigrid to review the task, then use Tyr to audit the session if needed." |
| "Score this from the summary." | "Fetch audit context and page session events before scoring." |
| "Paste a JSON score in chat." | "Persist the score through the audit workflow and report the stored result." |

Need a task acceptance decision first? Use [Sigrid](../sigrid/) before or alongside Tyr.