Progressiv afsløring: CLI-vinduer ind i agentsystemer

Tallene i dette indlæg afspejler systemet på udgivelsestidspunktet (januar 2026). Se vores team-side for aktuelle tal.

Agentsystemer er uigennemsigtige af design. De træffer beslutninger, kalder værktøjer og koordinerer arbejde på tværs af snesevis af specialister. Men når noget går galt — eller når du blot vil forstå, hvad der sker — hvor kigger du så?

Svaret er progressiv afsløring: en lagdelt grænseflade, der afslører præcis så meget kompleksitet, som du har brug for, præcis når du har brug for det.

Uigennemsigtighedsproblemet

Et moderne agent-orkestreringssystem kan have:

• 40+ specialiserede agenter, hver med distinkte kapabiliteter
• 700+ skills, der spænder over intern automatisering og leverandørintegrationer
• 470+ arkitektoniske beslutninger, der former adfærd
• Snesevis af MCP-værktøjsservere, der leverer eksterne kapabiliteter

Denne kompleksitet er tilsigtet. Agenter har brug for adgang til rig kontekst — domæneviden, code intelligence, databaseskemaer — for at træffe gode beslutninger. Men den samme rigdom skaber et synlighedsproblem.

Hvordan ved du, hvilken agent der håndterer databasemigreringer? Hvilke beslutninger formede søgesystemets rangeringsadfærd? Hvilke værktøjer har arkitekturrådgiveren adgang til?

Uden struktureret adgang er du henvist til at læse kildekode eller håbe, at dokumentationen er ajour.

Progressiv afsløring som arkitektur

Progressiv afsløring er ikke bare et UI-mønster. Det er et arkitektonisk princip: organisér information i lag, hvert dybere end det sidste, så brugere kan stoppe på det niveau, der besvarer deres spørgsmål.

For agentsystemer oversættes det til CLI-kommandoer i stigende dybder:

Niveau	Kommando	Spørgsmål, der besvares
1	orkestra system status	Er alt sundt?
2	orkestra agents list	Hvilke agenter findes der?
3	orkestra agents info <name>	Hvad gør denne agent?
4	orkestra decisions search	Hvorfor fungerer det på denne måde?
5	Maguyva MCP-værktøjer	Vis mig koden.

Hvert niveau besvarer et naturligt opfølgende spørgsmål. Du behøver sjældent at springe direkte til niveau 5.

Niveau 1: Systemsundhed

Det første spørgsmål er altid: virker alt?

$ orkestra system status

on
{
  "agents": 40,
  "skills_internal": 466,
  "skills_vendor": 240,
  "skills_total": 706,
  "commands": 17
}

Én kommando. Fire tal. Nok til at vide, at systemet er konfigureret, og at registrene er befolket.

Hvis et agentantal falder uventet, eller skills ikke kan indlæses, ser du det her først. Ingen log-dykning nødvendig.

Niveau 2: Agentbeholdning

Når du ved, at systemet er sundt, er det næste spørgsmål: hvad er tilgængeligt?

$ orkestra agents list

Dette returnerer strukturerede data — agentnavne, beskrivelser, modelpræferencer, domænedækning. Outputtet er JSON som standard, hvilket gør det nemt at pipe ind i jq til filtrering:

$ orkestra agents list | jq '.agents[] | select(.model == "opus") | .name'

Vil du have agenter, der håndterer databasearbejde? Søgekommandoen indsnævrer det:

$ orkestra agents search "database"

Dette skanner navne, beskrivelser og kapabiliteter. Du finder den rette specialist uden at læse 40 agentdefinitioner.

Niveau 3: Dybt agentdyk

Fandt du en agent, der ser relevant ud? info-kommandoen afslører alt:

$ orkestra agents info architecture-advisor

Outputtet inkluderer:

• Metadata: Navn, kategori, modelpræference, beskrivelse
• Domæner: Hvilke videnområder denne agent dækker
• Identitet: Karaktertræk (architect, strategist, knowledge-architect)
• Værktøjsguider: Hvilken værktøjsdokumentation der injiceres i konteksten
• Værktøjer: Den fulde liste af MCP-værktøjer, denne agent har adgang til

Her er et udpluk af, hvad du ser:

on
{
  "metadata": {
    "name": "architecture-advisor",
    "model": "opus",
    "description": "Strategic decision-making and architectural guidance..."
  },
  "domains": [
    "product",
    "development/architecture",
    "meta/strategy"
  ],
  "tools": {
    "mcp_tools": [
      "mcp__maguyva__intelligent_search",
      "mcp__maguyva__analyze_dependencies",
      "mcp__supabase__execute_sql",
      ...
    ]
  }
}

Dette fortæller dig præcis, hvad agenten kan gøre. Ingen kildekode nødvendig.

Niveau 4: Beslutningsarkæologi

Agenter opfører sig i henhold til dokumenterede beslutninger. Når du har brug for at forstå hvorfor noget fungerer på en bestemt måde, er beslutningsregistret den autoritative kilde.

$ orkestra decisions search "agent"

Dette returnerer matchende arkitektoniske beslutninger:

on
{
  "results": [
    {
      "id": "DEC-SR-049",
      "title": "AI-Agent-First Defaults with Graph Intelligence",
      "domain": "search",
      "status": "active"
    }
  ]
}

Hver beslutning har fuld proveniens — hvornår den blev truffet, hvorfor, hvilke afvejninger der blev overvejet, hvilke commits der implementerede den:

$ orkestra decisions info DEC-SR-049

on
{
  "id": "DEC-SR-049",
  "title": "AI-Agent-First Defaults with Graph Intelligence",
  "summary": "Changes default values for search tools to AI-agent-optimal behavior...",
  "rationale": [
    "AI agents work better with pre-ranked, importance-weighted results",
    "Graph metrics already computed by pipeline - leverage them",
    "Community context helps agents understand feature scope in single query"
  ],
  "source_commits": [
    {
      "sha": "156a880d05eae295669ef7c194b039023f245511",
      "message": "feat(maguyva): enable boost_by_importance..."
    }
  ]
}

Dette er arkitektonisk dokumentation, der forbliver ajour, fordi den er minet fra commits, ikke manuelt vedligeholdt.

Niveau 5: Direkte Code Intelligence

Når du har brug for at se den faktiske implementering — ikke metadata om den — giver Maguyvas MCP-værktøjer direkte adgang.

Indefra en agentsession:

mcp__maguyva__intelligent_search
  query: "agent context loading"

Dette auto-router på tværs af semantisk, tekst- og AST-søgning for at finde relevant kode. For specifikke symboler:

mcp__maguyva__find_symbol
  symbol_name: "load_agent_context"

For afhængighedsanalyse:

mcp__maguyva__analyze_dependencies
  target: "packages/orchestration/core/agents.py"

Det her er ikke bare grep-erstatninger. De er grafbevidste, semantisk indekserede og integreret med den samme code intelligence, der driver agenterne selv.

Samlet søgning på tværs af registre

Nogle gange ved du ikke, hvilket register der har svaret. Den samlede søgning spænder over alt:

$ orkestra search "database" --summary

on
{
  "query": "database",
  "total": 254,
  "counts": {
    "agents": 40,
    "skills": 59,
    "decisions": 476,
    "truths": 2,
    "packages": 1
  }
}

254 træffere på tværs af fem registre. Sammendraget fortæller dig, hvor du skal dykke ned. Fjern --summary for detaljerede resultater, eller tilføj --limit 5 for at holde outputtet håndterbart.

Hvorfor det betyder noget

Progressiv afsløring handler ikke kun om bekvemmelighed. Det ændrer, hvordan du interagerer med komplekse systemer.

Fejlfinding bliver håndterbar. Når en agent træffer en uventet beslutning, grepper du ikke gennem logs. Du tjekker, hvilke værktøjer den har adgang til (agents info), hvilke beslutninger der former dens adfærd (decisions search), og sporer implementeringen, hvis nødvendigt (intelligent_search).

Onboarding accelererer. Nye teammedlemmer behøver ikke at læse hele kodebasen. De starter med system status, udforsker med agents list, og går kun dybere, når de støder på noget, de ikke forstår.

Dokumentation forbliver ajour. Fordi CLI’en læser fra de samme registre, der konfigurerer agenterne, er outputtet altid præcist. Der er ingen drift mellem, hvad dokumentationen siger, og hvad systemet gør.

CLI’en som grænseflade

Vi kunne have bygget et webdashboard. Vi kunne have skrevet omfattende dokumentation. I stedet byggede vi en CLI, der læser fra den autoritative kilde.

CLI’en har fordele:

• Sammensætbar: Pipe output gennem jq, integrér med scripts
• Scriptbar: Automatisér tjek, generér rapporter
• Hurtig: Ingen sideindlæsninger, ingen godkendelsesflows
• Præcis: Læser den faktiske konfiguration, ikke en cachet repræsentation

For systemer, hvor korrekthed betyder mere end æstetik, vinder CLI’en.

Byg din egen progressive afsløring

Hvis du bygger agentsystemer, så overvej, hvordan brugere vil inspicere dem:

1. Start med sundhedstjek. Én kommando, der fortæller dig, om tingene fungerer.
2. Tilbyd beholdningsvisninger. List hvad der findes, før du forklarer, hvad det gør.
3. Muliggør målrettede forespørgsler. Søgning slår gennemsning i stor skala.
4. Eksponér proveniens. Lad brugere spore beslutninger til deres oprindelse.
5. Forbind til Code Intelligence. I sidste ende har brugere brug for at se implementeringen.

Hvert lag besvarer et opfølgende spørgsmål. Byg dem i frekvensrækkefølge — de fleste brugere stopper ved lag 2 eller 3. Kun poweruser når lag 5.

Målet er ikke at eksponere alt. Det er at eksponere præcis det, der er nødvendigt, præcis når det er nødvendigt. Det er progressiv afsløring anvendt på agentarkitektur.