# Mimir Knowledge Orchestrator
Mimir is the knowledge orchestrator for your Valdr workspace.

Think of Mimir as the investigator that turns "where is the evidence?" into "here are the sources, relationships, and next moves."

When you need evidence before taking action, start with Mimir. It can inspect attached docs, indexed code, source health, search relevance, symbol relationships, and agent memory notebooks, then return source-backed answers instead of guesses.

Mimir exists to answer a simple question before engineering work starts: what does the evidence actually say?

If Gunnar is the best first stop for "what work exists?", Mimir is the best first stop for "what do our sources say?" Use it when the answer should come from indexed knowledge, code relationships, or saved local learnings.

Mimir turns workspace knowledge into an operational surface. Instead of asking agents to work from stale context, route knowledge-heavy work through Mimir so sources are curated, indexes are healthy, search is scoped, code maps are explicit, and useful findings are recorded with provenance.

## What this page covers

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

## When you're new to Valdr

Start with Mimir when:

- You need to find where a behavior is documented
- You need to search indexed docs, code, or memory before creating work
- You need symbol relationships: definitions, references, callers, imports, tests, or docs
- You need to check whether knowledge sources are stale, failed, or missing
- You need to record a useful local learning for a future agent

The simple distinction is: Gunnar answers "what should happen next?" Mimir answers "what does the evidence say?"

> [!NOTE]
> Mimir is Sovereign-only because it depends on the `pm_knowledge` MCP tool.

## Use Mimir when

| Need | Ask Mimir to |
|------|--------------|
| Source curation | Attach, disable, remove, label, or re-weight knowledge sources |
| Index health | Refresh ingests, triage stale or failed resources, and check embedding-model availability |
| Knowledge search | Find relevant docs or code with scoped filters and retrieval-mode diagnostics |
| Code mapping | Locate definitions, references, callers, imports, tests, and docs for symbols |
| Memory capture | Append agent learnings to notebooks or snapshot meaningful Valdr records |
| Search troubleshooting | Explain why semantic search fell back, why a source is missing, or why a result ranked |

Mimir belongs in the loop when the answer depends on indexed knowledge or code relationships. For general PM navigation, start with [Gunnar](../gunnar/). For agent and pack design, start with [Nikol](../nikol/). For sprint execution, start with [Skadi](../skadi/).

## First five minutes with Mimir

A first Mimir session should feel like asking a careful researcher to show its work:

| You ask | Mimir helps by |
|---------|----------------|
| "Where is this behavior documented?" | Searching the local knowledge surface and showing the sources that explain it |
| "Where do we document session launch?" | Searching indexed docs and returning the source paths that matter |
| "What calls `pm_session.launch_task`?" | Mapping definitions, references, callers, tests, and related docs |
| "Why is this source not showing up in search?" | Checking source status, ingest health, and retrieval-mode behavior |
| "Record this reviewer learning." | Appending a scoped notebook entry with enough context for future agents |

This is the core value: Mimir makes workspace knowledge inspectable. New users often know the topic but not the source of truth. Mimir finds the evidence first, then helps decide whether the next step is a task, a pack change, a sprint action, or another search.

## How to use Mimir

{{% steps %}}

### Start with the knowledge question

Open the [Orchestrator UI](/valdr/docs/ui/orchestrator/) and choose **Mimir**, or launch an agent session with handle `mimir`. Name the project, source, path, symbol, or topic you care about. If the answer should come from docs, code, memory, or all indexed sources, say that up front.

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

```text
/valdr-orchestrator
Use mimir to search project VALDR for session launch idempotency and show the source paths.
```

### Let Mimir choose the workflow

Mimir should route the request before acting: source curation, ingest health, search retrieval, code mapping, or knowledge capture. For ambiguous requests, it can run a focused first pass and offer the next useful deepening.

### Inspect the evidence

Ask for source paths, symbol names, result ranking notes, or retrieval diagnostics when the answer will guide another agent. Mimir is strongest when it shows why a result matters, not just that a match exists.

### Keep source changes explicit

Attaching, removing, disabling, or re-weighting sources changes future retrieval. Ask Mimir to show the source curation plan before destructive changes or broad batches, then approve the mutations you want.

### Capture useful learnings

When a finding should help future agents, ask Mimir to append a self-contained note to the right agent notebook or snapshot a meaningful Valdr record. The note should include the subject, what changed, why it matters, and references.

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

Mimir is the best first stop when the request depends on source-backed knowledge. Switch once the evidence points to action: Gunnar can shape the task, Nikol can encode reusable behavior, and Skadi can coordinate sprint execution.

## Strong prompts

Use Mimir for knowledge-heavy work:

- "Search project `VALDR` for how session launch idempotency is documented and show the top source paths."
- "Find the definition and references for `pm_knowledge` search handling."
- "Check knowledge status for this project and tell me which sources are stale or failed."
- "Attach this docs folder as an operational source, then run an incremental ingest."
- "Record this reviewer learning for `sigrid` with the task key and file references."

The best Mimir prompts include a scope and a question shape: prose search, symbol navigation, source curation, ingest health, or memory capture. If you only know the topic, ask Mimir to run a compact first pass and explain what it searched.

## Typical workflow

1. Ask Mimir to scope the source, topic, path, or symbol.
2. Ask Mimir to search indexed knowledge or map code relationships.
3. Ask Mimir to explain the evidence, provenance, and confidence.
4. Fix source or index health if the retrieval surface is stale.
5. Hand off to Gunnar, Nikol, Skadi, or an executor once the evidence has shaped the next action.

This keeps evidence gathering and execution separate. Mimir finds the proof; the next agent acts on it.

## How Mimir is built (advanced)

The Sovereign pack defines Mimir as a knowledge orchestration specialist:

| Capability | Role | Use |
|------------|------|-----|
| `valdr.orchestrator.mimir.system` | Core | Identity, intent routing, direct status operations, and Sovereign-only boundaries |
| `valdr.orchestrator.mimir.source-curation` | Workflow | Attach, remove, disable, label, and re-weight knowledge sources with trust-tier discipline |
| `valdr.orchestrator.mimir.ingest-health` | Workflow | Run ingests, triage stale or failed resources, and decide incremental versus rebuild mode |
| `valdr.orchestrator.mimir.search-retrieval` | Workflow | Shape prose searches with filters, retrieval mode, response profiles, and score diagnostics |
| `valdr.orchestrator.mimir.code-mapping` | Workflow | Use `code_map` for definitions, references, callers, imports, tests, docs, and symbol relationships |
| `valdr.orchestrator.mimir.knowledge-capture` | Workflow | Append agent memory, snapshot Valdr records, and audit notebooks |
| `valdr.core.knowledge.search` | Shared workflow | Search mechanics used by Mimir, planners, executors, and reviewers |
| `valdr.core.knowledge.code-map` | Shared workflow | Code-map mechanics for symbol-aware discovery |
| `valdr.core.knowledge.memory-append` | Shared workflow | Agent notebook appends while local data exists |
| `valdr.core.knowledge.record-snapshot` | Shared workflow | Materialized task, sprint, plan, or review snapshots at meaningful transitions |

Mimir's orchestration layer handles intake, scope, provenance, and response shape. The shared `valdr.core.knowledge.*` capabilities carry the underlying tool mechanics, so other agents can use routine search or code-map flows directly when they do not need a knowledge specialist.

## What Mimir should not do

Mimir is not a general PM navigator, sprint coordinator, or coding agent. Do not use it to edit files, launch task sessions, or normalize sprint state. Use it to curate what Valdr knows, retrieve the right evidence, map code relationships, and record local learnings.

| Instead of asking Mimir to... | Ask Mimir to... |
|-------------------------------|-----------------|
| "Create a feature task for OAuth support." | "Search docs and code for existing OAuth patterns, then give Gunnar the source-backed context for a task." |
| "Fix the `code_map` implementation." | "Find the definitions, references, tests, and docs for `code_map` so an executor can work from evidence." |
| "Prepare the next sprint." | "Find the evidence behind the sprint risk, then hand execution coordination to Skadi." |

Ready to turn a finding into work? Use [Gunnar](../gunnar/) to shape the task, [Nikol](../nikol/) to encode reusable agent behavior, or [Skadi](../skadi/) to coordinate execution.