# Included agents
The Valdr core pack ships with a complete roster of agents — orchestrators, specialists, and task executors — ready to import and use. These aren't demos. They're the same agents that power Valdr's internal workflows.

## Orchestrators

Orchestrators coordinate work across your workspace. Each specializes in a domain.

### Gunnar — Project Management

**Handle:** `gunnar` | **Role:** orchestrator

Gunnar is the PM navigation specialist. It knows how to find projects, tasks, sprints, agents, and plans — and how they relate to each other.

**Capabilities:**
- `valdr.orchestrator.gunnar.system` — Core identity and tool index
- `valdr.orchestrator.gunnar.navigation` — Finding and exploring entities (hot-loaded)
- `valdr.orchestrator.gunnar.registry` — Browsing agents, prompts, capabilities (hot-loaded)

**Use when:** You need workspace context — "What projects exist?", "Show me open tasks", "What's the sprint status?"

### Nikol — Agent Registry

**Handle:** `nikol` | **Role:** orchestrator

Nikol manages the agent registry — creating agents, authoring prompts, linking capabilities, and designing agent architectures.

**Capabilities:**
- `valdr.orchestrator.nikol.system` — Core identity
- Agent design and capability authoring workflows (hot-loaded)

**Use when:** You need to create or update agents, write prompts, link capabilities, or design agent architectures.

### Skadi — Sprint Management

**Handle:** `skadi` | **Role:** orchestrator

Skadi handles sprint orchestration — planning sprints, staffing tasks, routing reviewers, and verifying launch readiness.

**Capabilities:**
- `valdr.orchestrator.skadi.system` — Core identity
- `valdr.orchestrator.skadi.sprint-planning` — Sprint creation and scoping (hot-loaded)
- `valdr.orchestrator.skadi.task-staffing` — Assigning executors (hot-loaded)
- `valdr.orchestrator.skadi.review-routing` — Assigning reviewers (hot-loaded)
- `valdr.orchestrator.skadi.launch-readiness` — Pre-launch verification (hot-loaded)

**Use when:** You need to create sprints, assign work, set up review coverage, or verify launch readiness.

## Specialists

Specialists own a specific workflow domain with deep capabilities.

### Sigrid — Code Reviewer

**Handle:** `sigrid` | **Role:** reviewer

Sigrid is the code review gatekeeper. It reviews task work, classifies findings by severity, scores against quality dimensions, and controls the verification gate.

**Capabilities:**
- `valdr.reviewer.sigrid.system` — Core identity and review protocol
- `valdr.reviewer.sigrid.workflow` — Review flow and decision process (hot-loaded)
- `valdr.reviewer.sigrid.severity` — Finding severity classification (hot-loaded)
- `valdr.reviewer.sigrid.scoring` — Score/status alignment rules (hot-loaded)

**Use when:** Tasks need code review before they can be verified and completed.

### Freya — Feature Planner

**Handle:** `freya` | **Role:** planner

Freya turns ideas into structured plans with requirements, acceptance criteria, and executable tasks. Plans are drafted as Markdown, reviewed by users, and committed atomically.

**Capabilities:**
- `valdr.planner.freya.system` — Core identity and planning protocol
- Schema validation and task generation workflows (hot-loaded)

**Use when:** You need to break down a feature into structured, executable work.

### Tyr v2 — Session Auditor

**Handle:** `tyr-v2` | **Role:** auditor

Tyr evaluates agent sessions across seven quality dimensions with evidence-based findings and structured verdicts. Every score requires evidence — no evidence, no score.

**Capabilities:**
- `valdr.auditor.tyr.v2.system` — Core identity and audit protocol
- Constraint, validation, and scoring capabilities (hot-loaded)

**Seven scoring dimensions:** Instructions adherence, prompt integrity, tooling compliance, task correctness, risk safety, execution quality, task quality.

**Use when:** You need to evaluate how well an agent performed — not just "did it finish" but "did it follow the process correctly."

## Task Executors

Task executors implement work in specific technology domains. They follow the executor workflow pattern: fetch task, update status, work incrementally, self-review, then stop.

### Language-specific agents

| Agent | Handle | Domain |
|-------|--------|--------|
| **TypeScript** | `typescript-task-agent` | TypeScript/JavaScript projects |
| **Go** | `go-task-agent` | Go projects |
| **Java** | `java-task-agent` | Java/JVM projects |
| **Python** | `python-task-agent` | Python projects |
| **Rust** | `rust-task-agent` | Rust projects |

### Domain-specific agents

| Agent | Handle | Domain |
|-------|--------|--------|
| **CI/CD** | `cicd-agent` | Pipeline configuration and deployment |
| **Security** | `security-agent` | Security auditing and vulnerability analysis |
| **Infrastructure** | `infra-agent` | Infrastructure and DevOps patterns |
| **Dependency Audit** | `dependency-audit-scout` | Dependency analysis (JVM, NPM, Cargo) |
| **Refactor Scout** | `refactor-agent` | Codebase refactoring opportunities |
| **Hugo Docs** | `hugo-docs-agent` | Hugo documentation steward |
| **Bun Build** | `bun-build-agent` | Bun build scanning and hardening |

Each agent comes with its own `.agent.yaml`, system capability, and domain-specific prompts.

## Core capabilities

Beyond agents, the pack includes shared capabilities that any agent can reference:

### MCP tool capabilities

Structured documentation for every PM MCP tool:

| Capability | Covers |
|-----------|--------|
| `valdr.core.tools.pm-project` | Project operations |
| `valdr.core.tools.pm-task` | Task lifecycle |
| `valdr.core.tools.pm-sprint` | Sprint management |
| `valdr.core.tools.pm-review` | Review operations |
| `valdr.core.tools.pm-agent` | Agent registry |
| `valdr.core.tools.pm-prompt` | Prompt management |
| `valdr.core.tools.pm-capability` | Capability operations |
| `valdr.core.tools.pm-session` | Session management |
| `valdr.core.tools.vmp` | VMP planning |

These are hot-loaded by agents that need specific tool documentation during execution.

### Executor workflow capabilities

The executor workflow is decomposed into hot-loadable steps that any executor agent inherits:

- Status transitions, checklist management, self-review protocol
- Code-change validation (tests, lints)
- Comment and documentation updates

## Pack statistics

The Valdr core pack includes:

| Entity | Count |
|--------|-------|
| Agents | 26 |
| Capabilities | 156 |
| Prompts | 168 |
| Sub-packs | 1 (valdr) |

## Extending the roster

The included agents cover common workflows, but every team has unique needs. Use the [team capabilities](../team-capabilities/) system to layer your conventions on top of these agents, or use the [Orchestrator skill](/docs/skills/valdr-orchestrator/) to handle registry operations and create entirely new agents.