# Gunnar Orchestrator
Gunnar is the project coordinator for your Valdr workspace.

When you are not sure what exists, what needs attention, or what should happen next, start with Gunnar. It can inspect projects, tasks, sprints, agents, capabilities, and prompts, then turn that context into a clear next move.

If you only learn one orchestrator first, learn Gunnar. Most workflows begin with understanding the current state of the workspace, and Gunnar is optimized for exactly that problem.

Most users begin with Gunnar before handing execution to Skadi, Mimir, Nikol, or a task executor. Gunnar helps you discover the work before another agent does the work.

## What this page covers

- Why Gunnar is usually the first orchestrator to use
- How a first Gunnar session feels
- When to switch from Gunnar to another orchestrator
- What advanced workflows Gunnar can hot-load

## When you're new to Valdr

Start with Gunnar when:

- You do not know what projects exist
- You need to find active, blocked, or in-review work
- You need to create a task from a rough idea
- You need to understand the state of a sprint
- You need to figure out which agent should handle something

Think of Gunnar as the coordinator that turns "what is going on?" into "here is the next useful action."

## Use Gunnar when

| Need | Ask Gunnar to |
|------|---------------|
| Project orientation | List projects, summarize status, or explain how project records relate |
| Task discovery | Find open, blocked, in-review, or recently changed tasks |
| Sprint context | Show sprint membership, active sprint state, and readiness gaps |
| Registry discovery | List agents, prompts, and capabilities by role, handle, or capability key |
| Task creation | Research a bug, feature, spike, or refactor and compose a standalone task |

Gunnar is intentionally coordination-focused. It can read code for context, but it should not be your implementation agent. When work needs source changes, use Gunnar to create a clear task and route it to the right executor.

## First five minutes with Gunnar

A first Gunnar session should feel like turning on the lights in your workspace:

| You ask | Gunnar helps by |
|---------|-----------------|
| "What projects do I have?" | Listing projects and showing where active work lives |
| "What is blocked?" | Finding blocked tasks, review gaps, or sprint readiness issues |
| "Create a task for adding release notes." | Drafting a task with enough context and acceptance criteria for an executor |
| "Who should work on it?" | Suggesting the next agent or handoff path based on the work |

This is the core value: Gunnar helps you discover work. New users often do not know which project matters, what is active, what is stuck, or which agent should run next. Gunnar gives you that operating picture before you spend time in the wrong place.

## How to use Gunnar

{{% steps %}}

### Start with the workspace question

Open the [Orchestrator UI](/valdr/docs/ui/orchestrator/) and choose **Gunnar**, or launch an agent session with handle `gunnar`. Ask the broad question first: what projects exist, what is active, what is blocked, or what needs to become a task.

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

```text
/valdr-orchestrator
Use gunnar to show active tasks for project VALDR and call out blockers.
```

### Narrow to the useful state

Give Gunnar a project key, sprint name, task key, agent handle, or rough work idea. The more specific the scope, the faster Gunnar can fetch the right records and avoid guessing.

### Ask Gunnar to explain the next move

Gunnar should inspect current state before recommending action. Ask it to call out blockers, missing context, likely owners, or whether the work should become a task, a sprint item, a registry change, or a knowledge search.

### Create or refine the work

When the request needs a task, Gunnar can turn the idea into a structured bug, feature, spike, or refactor with acceptance criteria. Keep the task focused enough that an executor can pick it up without another discovery pass.

### Route to the right specialist

Use Gunnar's output to choose the handoff: ask Mimir to investigate knowledge, ask Nikol to improve an agent or pack, hand off to Skadi for sprint coordination, or launch an executor against a ready task.

{{% /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** |

Gunnar is the best first stop when the request is still fuzzy. Switch once the work has a clearer shape: knowledge questions go to Mimir, agent-system changes go to Nikol, and execution coordination goes to Skadi.

## Strong prompts

Use Gunnar for questions that need workspace and task context:

- "Show active tasks for project `VALDR` and call out blockers."
- "Find tasks in review that do not have reviewer coverage."
- "List executor agents and summarize what each one is for."
- "Create a feature task for adding project-level release notes. Include acceptance criteria."
- "Look at this bug report and draft a standalone task an executor can pick up."

The best Gunnar prompts name the project, task, sprint, or registry area you care about. If you only have a rough idea, say that directly and ask Gunnar to research before drafting.

## Typical workflow

1. Ask Gunnar to inspect project or sprint state.
2. Ask Gunnar to identify active work, blockers, or missing context.
3. Ask Gunnar to draft or refine a task when the work is not yet executable.
4. Ask Gunnar which agent should own the next step.
5. Hand off to Mimir, Nikol, Skadi, or an executor once the work is clearly shaped.

This keeps exploration and execution separate. Gunnar builds the map; the next agent follows it.

## How Gunnar is built (advanced)

The Sovereign pack defines Gunnar with one core capability and several hot-loaded workflows:

| Capability or prompt | Role | Use |
|----------------------|------|-----|
| `valdr.orchestrator.gunnar.system` | Core | Identity, direct operations, tool index, and operating rules |
| `valdr.orchestrator.gunnar.navigation` | Workflow | Deep exploration across projects, tasks, plans, sprints, and relationships |
| `valdr.orchestrator.gunnar.registry` | Workflow | Agent, prompt, and capability discovery or registry health checks |
| `valdr.orchestrator.gunnar.task-creation` | Workflow | Research-driven task creation with type-specific templates |
| `valdr.core.sizing.ai-story-points` | Context | AI-agent story point sizing when Gunnar drafts or evaluates work |
| `valdr-orchestrator-gunnar-template-*` | Guide | Bug, feature, spike, and refactor task templates |

This composition keeps everyday lookup fast while making deeper navigation, registry analysis, and task creation repeatable. You do not need to know these capability keys to start using Gunnar; they matter when you want to understand how the Sovereign pack assembles the agent internally.

## What Gunnar should not do

Gunnar is not the coding agent. Do not use it to edit files, perform implementation, or run risky shell commands. Use it to discover the work, shape the task, and route the next agent with enough context to execute cleanly.

| Instead of asking Gunnar to... | Ask Gunnar to... |
|--------------------------------|------------------|
| "Implement OAuth support." | "Create a task for OAuth support, identify the missing context, and recommend the best executor." |
| "Fix the failing release workflow." | "Find the release workflow task or draft one with acceptance criteria, then route it to the right specialist." |

Ready for deeper coordination? Use [Skadi](../skadi/) after Gunnar has identified sprint scope or launch-readiness gaps. Need source-backed answers first? Use [Mimir](../mimir/) for knowledge search and code mapping.