# Skadi Sprint Orchestrator
Skadi is the sprint orchestrator for your Valdr workspace.

When work needs to move through a controlled delivery loop, start with Skadi. It coordinates sprint scope, task readiness, executor assignment, reviewer coverage, launch, review follow-up, completion, and worktree-aware closeout.

If Gunnar builds the map, Skadi turns a ready task set into an inspectable delivery rhythm. Use it when the question is no longer "what should we do?" but "how do we move this work through execution cleanly?"

Skadi keeps multi-agent delivery from becoming manual bookkeeping. Instead of remembering who should run next, which review is missing, or whether a task is safe to launch, Skadi checks current state and coordinates the next step.

## What this page covers

- When Skadi is the right orchestrator to use
- How a first Skadi session feels
- When to switch from Skadi to another orchestrator
- What advanced session-aware workflows Skadi can hot-load

## When you're new to Valdr

Start with Skadi when:

- You have a sprint, plan, backlog slice, or task list to prepare
- You need to know which tasks are ready to launch and which are blocked
- You need executor assignments across multiple tasks
- You need reviewer coverage and review-session launch paths
- You need to message active sessions, avoid duplicate launches, or coordinate closeout

Think of Skadi as the delivery coordinator that turns "these tasks should move" into "this is ready, this is blocked, and this is the next safe action."

## Use Skadi when

| Need | Ask Skadi to |
|------|--------------|
| Sprint setup | Create or prepare a sprint from a plan, backlog set, or explicit task list |
| Scope management | Add or remove tasks using sprint membership operations |
| Staffing | Assign executor ownership using available agent handles and task fit |
| Review routing | Assign reviewer coverage and launch reviewer sessions correctly |
| Launch readiness | Verify status, assignee, priority, points, and reviewer gates |
| Session coordination | Launch executor sessions, message active sessions, and avoid duplicate launches |
| Completion flow | Verify reviews, close tasks, and coordinate worktree-aware completion steps |

Skadi belongs in the loop when the work spans multiple tasks or multiple agents. For a single PM lookup or rough idea, start with [Gunnar](../gunnar/). For source-backed investigation, start with [Mimir](../mimir/). For agent design, start with [Nikol](../nikol/).

## First five minutes with Skadi

A first Skadi session should feel like opening a sprint control board:

| You ask | Skadi helps by |
|---------|----------------|
| "Prepare this sprint from the current plan." | Building scope, checking readiness, and reporting gaps |
| "Which tasks are not ready to launch?" | Checking status, assignee, priority, points, and reviewer coverage |
| "Assign executors for these tasks." | Routing work to suitable agent handles with traceable ownership |
| "Launch reviewers for tasks in review." | Using the review launch path so reviewers attach to the right worktree |

This is the core value: Skadi makes execution state explicit. New users often know the work they want done but not whether the sprint is launch-ready. Skadi exposes the gaps before sessions start.

## How to use Skadi

{{% steps %}}

### Give Skadi the sprint scope

Open the [Orchestrator UI](/valdr/docs/ui/orchestrator/) and choose **Skadi**, or launch an agent session with handle `skadi`. Provide a project key and either a plan, sprint name, task list, or backlog filter. Skadi needs a concrete scope before it can check readiness.

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

```text
/valdr-orchestrator
Use skadi to prepare the next sprint from these tasks and report launch-readiness gaps.
```

### Let Skadi inspect before changing state

Skadi should fetch project, sprint, task, review, and agent state before applying updates. This keeps sprint membership and assignments traceable.

### Resolve readiness gaps

Expect Skadi to call out missing assignees, missing reviewer coverage, non-ready statuses, and missing priority or points. Approve the fixes you want before Skadi mutates PM state.

### Launch through the correct path

In Sovereign workflows, Skadi launches executors through task sessions and reviewers through review sessions so reviewers attach to the executor's worktree instead of a separate task worktree.

### Keep active sessions in view

When work is already running, ask Skadi to message or inspect the existing session before launching another one. This preserves the execution trail and avoids duplicate work.

{{% /steps %}}

## Which orchestrator should I use?

| Need | Start with |
|------|------------|
| Understand workspace state, projects, tasks, or sprints | **Gunnar** |
| Investigate knowledge sources, indexed docs/code, or symbol relationships | **Mimir** |
| Design agents, capabilities, prompts, or pack structure | **Nikol** |
| Coordinate sprint execution, staffing, review routing, or session launch | **Skadi** |

Skadi is the best first stop when work is already shaped and needs coordinated movement. Switch back to Gunnar if scope is unclear, to Mimir if readiness depends on source-backed investigation, or to Nikol if execution reveals a reusable agent-system gap.

## Strong prompts

Use Skadi for workflow coordination:

- "Prepare the next sprint for project `VALDR` from the current plan and report readiness gaps."
- "Assign executors for these sprint tasks using deterministic routing."
- "Route reviewers for tasks currently in review and launch reviewer sessions where needed."
- "Check whether this sprint is ready to activate."
- "Message the existing executor session with the review feedback instead of launching a duplicate."

The best Skadi prompts name the project and the desired workflow phase. If you know the task keys, include them. If not, ask Skadi to discover scope first and report before changing anything.

## Typical workflow

1. Ask Skadi to inspect sprint scope, task state, and active sessions.
2. Ask Skadi to report readiness gaps before changing PM state.
3. Approve assignment, reviewer routing, or sprint membership updates.
4. Ask Skadi to launch or message sessions through the correct path.
5. Ask Skadi to verify reviews, completion state, and worktree readiness before closeout.

This keeps sprint coordination and implementation separate. Skadi controls the delivery loop; executors and reviewers do the task work.

## How Skadi is built (advanced)

The Sovereign pack defines Skadi as a session-aware sprint orchestrator:

| Capability | Role | Use |
|------------|------|-----|
| `valdr.orchestrator.skadi.system` | Core | Identity, operating rules, readiness gates, and launch-path safety |
| `valdr.orchestrator.skadi.sprint-prep` | Workflow | End-to-end sprint preparation from a plan or scoped task set |
| `valdr.orchestrator.skadi.sprint-planning` | Workflow | Sprint kickoff, rollover, and scope checks |
| `valdr.orchestrator.skadi.task-staffing` | Workflow | Executor assignment and staffing patterns |
| `valdr.orchestrator.skadi.review-routing` | Workflow | Reviewer assignment, reviewer launch, and review-flow monitoring |
| `valdr.orchestrator.skadi.launch-readiness` | Workflow | Status, assignee, reviewer, priority, and points checks |
| `valdr.orchestrator.skadi.launch-executor` | Workflow | Executor launch mode, preset resolution, and task session dispatch |
| `valdr.orchestrator.skadi.session-messaging` | Workflow | Re-engaging active sessions without relaunching |
| `valdr.orchestrator.skadi.task-completion` | Workflow | Review verification, completion, and next-task launch |
| `valdr.orchestrator.skadi.worktree-merge` | Workflow | Worktree inspection and merge verification during closeout |

Skadi is where Valdr's professional-grade agent operations become visible: task state, reviewer coverage, session history, and completion gates all stay inspectable.

## What Skadi should not do

Skadi should not silently normalize a sprint. Moving statuses, assigning owners, routing reviewers, or launching sessions are meaningful operations. Ask Skadi for the readiness report first, then approve the mutations you want.

| Instead of asking Skadi to... | Ask Skadi to... |
|-------------------------------|-----------------|
| "Launch every task in this sprint." | "Check launch readiness for the sprint, report blockers, and wait for approval before launching ready tasks." |
| "Move everything to done." | "Verify review state, completion criteria, and worktree readiness before closing tasks." |
| "Launch a reviewer like a normal task." | "Route the review through the reviewer launch path so it attaches to the executor's worktree." |

Ready to start from a rough idea instead of a sprint? Use [Gunnar](../gunnar/) to create the task, [Mimir](../mimir/) to find supporting evidence, or [Nikol](../nikol/) to design the agent capability before Skadi coordinates execution.