synops-agent: orkestreringsmodell med tre intelligensnivåer

- Kjørbar fra Claude Code via Bash (delegering til billige modeller)
- Tre nivåer: orkestrator (smart), implementering (middels), grunt (billig)
- «Utfør billig, verifiser smart»-strategi: ~90% på billigste modell
- Automatisk modellvalg basert på oppgavetype og eskalering ved feil
- Eksperimentering: logger modell/kostnad/resultat for optimalisering
- Claude Code som super-orkestrator over multi-modell agent-pool

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

docs/proposals/agent_harness.md

@@ -283,8 +283,133 @@ ressurser som agenter oppdager og laster dynamisk.
 7. **Enkel arkitektur** — Anthropic har rett: komponerbare patterns
    slår komplekse frameworks.
 
+## Orkestreringsmodell: smart leder, billige arbeidere
+
+### Kjørbar fra Claude Code
+
+synops-agent er et CLI-verktøy. Claude Code kan kalle det via Bash.
+Det betyr at Claude Code (dyr, smart) kan delegere arbeid til billige
+modeller uten å bruke egne tokens:
+
+```
+# Claude Code kjører dette:
+synops-agent --model gemini-flash --task "finn alle filer som importerer auth.ts"
+synops-agent --model grok-3-mini --task "skriv enhetstester for denne funksjonen"
+synops-agent --model claude-haiku --task "oppsummer disse 40 filene"
+```
+
+Claude Code beholder det store bildet. synops-agent gjør gruntarbeidet.
+
+### Tre intelligensnivåer
+
+```
+┌─────────────────────────────────────────────┐
+│  ORKESTRATOR (Claude Opus / Sonnet)         │
+│  Planlegger, arkitekturbeslutninger,        │
+│  kvalitetsvurdering, strategi               │
+├─────────────────────────────────────────────┤
+│  MIDDELS (Sonnet / Grok / Gemini Pro)       │
+│  Implementering, refaktorering,             │
+│  code review, feilsøking                    │
+├─────────────────────────────────────────────┤
+│  BILLIG (Haiku / Flash / Grok Mini)         │
+│  Søk, grep, oppsummering, formatering,      │
+│  enhetstester, dokumentasjon, triage        │
+└─────────────────────────────────────────────┘
+```
+
+Orkestratoren (Claude Code eller synops-agent med smart modell)
+bestemmer hvilket nivå hver deloppgave krever. Hvert nivå kan ha
+sin egen agent-loop med fulle verktøy.
+
+### Utfør billig, verifiser smart
+
+Kjernestrategi for kostnadseffektiv kvalitet:
+
+```
+1. Orkestrator bryter ned oppgaven i steg
+2. Billig modell utfører hvert steg (kode, søk, etc.)
+3. Smart modell verifiserer resultatet
+4. Ved feil: eskaler til middels/smart for retry
+5. Ved gjentatt feil: orkestrator tar over selv
+```
+
+Eksempel — fiks 10 TODO-er i kodebasen:
+```
+Orkestrator (Opus): "Her er 10 TODO-er, fiks dem én om gangen"
+  → Agent (Flash): fikser TODO #1, committer
+  → Orkestrator (Opus): review diff — "OK, neste"
+  → Agent (Flash): fikser TODO #2, committer
+  → Orkestrator (Opus): review diff — "Feil. La meg forklare..."
+  → Agent (Sonnet): fikser TODO #2 med bedre kontekst
+  → Orkestrator (Opus): review diff — "Bra, neste"
+```
+
+Kostnad: ~90% av arbeidet på billigste modell, ~8% på middels,
+~2% på dyreste. Kvaliteten til dyreste modell.
+
+### Automatisk modellvalg
+
+synops-agent kan velge modell basert på oppgavens karakter:
+
+| Signal | Nivå | Modell |
+|--------|------|--------|
+| `--task "søk etter..."` | Billig | Flash/Mini |
+| `--task "implementer..."` | Middels | Sonnet/Pro |
+| `--task "design..."` | Smart | Opus |
+| Feilet med billig | Eskaler | Middels → Smart |
+| `--verify` flagg | Smart | Opus (kun review) |
+| `--budget 0.10` | Auto | Billigst mulig |
+
+Maskinrommets `ai_job_routing`-tabell kan styre default-mappingen.
+
+### Claude Code som super-orkestrator
+
+Det ultimate mønsteret:
+
+```
+Claude Code (interaktiv med Vegard)
+  │
+  ├── "Fiks alle bugs i fikseliste.md"
+  │     └── synops-agent --model sonnet --tasklist fikseliste.md
+  │           ├── Bug 1 → agent (flash) → verifiser (sonnet) ✓
+  │           ├── Bug 2 → agent (flash) → verifiser (sonnet) ✗
+  │           │            → eskaler → agent (sonnet) → verifiser ✓
+  │           └── Bug 3 → agent (flash) → verifiser (sonnet) ✓
+  │
+  ├── "Research denne teknologien"
+  │     └── synops-agent --model grok-3 --task "..." (sanntidsinfo)
+  │
+  └── "Optimaliser databasespørringene"
+        └── synops-agent --model gemini-pro --task "..."
+             └── Sub-agent (flash): "profiler denne spørringen"
+```
+
+Claude Code bruker sin kontekst til å forstå hva som trengs,
+delegerer utføringen, og bruker resultatet. Billigere, raskere,
+og med tilgang til modeller Claude Code ikke har (Grok for
+sanntid, Gemini for lange kontekster, lokale modeller for
+sensitive data).
+
+### Eksperimentering med modellvalg
+
+synops-agent logger modell, oppgavetype, kostnad, tid og resultat
+(suksess/feil/eskalert) i `ai_usage_log`. Over tid bygges data
+som viser:
+
+- Hvilke modeller som er best per oppgavetype
+- Kostnadsoptimal eskaleringsterskel
+- Modeller som feiler oftere på spesifikke oppgaver
+- ROI for verify-steg (fanger det faktisk feil?)
+
+Claude Code kan analysere denne dataen og justere strategi:
+"Gemini Flash feiler på 40% av refaktoreringsjobber — bruk Sonnet
+for de fra nå av, men behold Flash for søk og dokumentasjon."
+
 ## Prioritet
 
 Middels-høy. Erstatter fragil infrastruktur (shell-scripts, looper)
 med noe robust. Kan bygges inkrementelt — fase 1 er allerede nyttig.
 Rig som avhengighet reduserer scope for fase 1-2 betydelig.
+Orkestrerings-mønsteret gir umiddelbar verdi: Claude Code kan
+delegere til billige modeller fra dag 1 av fase 1.