boc/ORCHESTRATION_V2.md

# AAMOS Orkestrering V2 — Analys & Förbättringar

## Nuvarande State (efter Kimi-integration)

### Agenter
| Agent | Modell | Roll | Trigger |
|-------|--------|------|---------|
| Bernt | Kimi K2.6 | Chief Orchestrator | on-demand |
| Hermes | Kimi K2.6 | Communication | event-driven |
| Sven | Qwen3 32B | Technical | on-demand |

### Routing (model-router)
```
AUDIT  → Qwen3 235B
AGENT  → Kimi K2.6
code   → Kimi K2.7 Code
complex→ Qwen3 32B
default→ Qwen3 32B
```

## Identifierade Brister

### 1. Ingen dynamisk lastbalansering
- Alla AGENT-tasks går till Kimi — ingen fallback vid överbelastning
- Ingen hälsokontroll av providers

### 2. Statisk modellallokering
- Sven är låst till Qwen3 — trots att Kimi är bättre på kodning
- Ingen "auto-select" baserat på uppgiftens natur

### 3. Saknar parallell exekvering
- intelligenceRouter kör en task åt gången
- Ingen "swarm"-effektivitet

### 4. Ingen minnesdelning mellan agenter
- Varje agent startar från noll
- Ingen kontextöverföring Bernt → Sven → Hermes

### 5. Begränsad felhantering
- Ett fel = hela kedjan stannar
- Ingen "degrade gracefully"

---

## Förbättringsförslag V2

### 1. Dynamisk Load Balancer
```javascript
// Ny fil: api/load-balancer.mjs
export async function routeWithFallback(task, message, system, messages) {
  const providers = [
    { name: 'kimi', weight: 0.5, healthy: true },
    { name: 'bedrock', weight: 0.3, healthy: true },
    { name: 'groq', weight: 0.2, healthy: true },
  ];
  
  // Välj baserat på vikt + hälsa
  const available = providers.filter(p => p.healthy);
  const selected = weightedRandom(available);
  
  try {
    return await execute(selected, task, message, system, messages);
  } catch (e) {
    // Markera som unhealthy, retry med nästa
    selected.healthy = false;
    return routeWithFallback(task, message, system, messages);
  }
}
```

### 2. Task-Specifik Modellval
```javascript
// Förbättrad selectModel med multi-factor
export function selectModelV2(task, message, context) {
  const factors = {
    codeComplexity: analyzeCodeComplexity(message),
    contextSize: estimateTokens(context),
    urgency: context.urgency || 'normal',
    compliance: context.complianceMode || 'commercial-eu',
  };
  
  // Decision tree
  if (factors.codeComplexity > 0.8) return MODELS.KIMI_K2_7_CODE;
  if (factors.contextSize > 100000) return MODELS.KIMI_K2_6; // 256K context
  if (factors.urgency === 'critical') return MODELS.KIMI_K2_7_HIGHSPEED;
  if (factors.compliance === 'sovereign-cn') return MODELS.QWEN_235B;
  
  return selectModel(task, message); // fallback till nuvarande
}
```

### 3. Parallell Swarm Exekvering
```javascript
// Ny fil: api/swarm-orchestrator.mjs
export async function swarmExecute(tasks, sharedContext) {
  // Kör flera tasks parallellt med delad kontext
  const promises = tasks.map(task => 
    intelligenceRouter(task.type, task.message, sharedContext.system, [
      ...sharedContext.history,
      { role: 'user', content: task.message }
    ])
  );
  
  const results = await Promise.allSettled(promises);
  
  // Sammanställ resultat
  return {
    successful: results.filter(r => r.status === 'fulfilled').map(r => r.value),
    failed: results.filter(r => r.status === 'rejected').map(r => r.reason),
    summary: generateSummary(results),
  };
}
```

### 4. Kontext-Memory mellan Agenter
```javascript
// Ny fil: api/agent-memory.mjs
const _agentMemory = new Map();

export function shareContext(fromAgent, toAgent, context) {
  const key = `${fromAgent}→${toAgent}`;
  _agentMemory.set(key, {
    context,
    timestamp: Date.now(),
    ttl: 300000, // 5 minuter
  });
}

export function getSharedContext(fromAgent, toAgent) {
  const key = `${fromAgent}→${toAgent}`;
  const entry = _agentMemory.get(key);
  if (!entry) return null;
  if (Date.now() - entry.timestamp > entry.ttl) {
    _agentMemory.delete(key);
    return null;
  }
  return entry.context;
}
```

### 5. Graceful Degradation
```javascript
// Uppdaterad intelligenceRouter med retry-logik
export async function intelligenceRouterV2(task, message, system, messages = [], options = {}) {
  const { retries = 3, fallbackChain = ['kimi', 'bedrock', 'groq', 'claude'] } = options;
  
  for (let attempt = 0; attempt < retries; attempt++) {
    const provider = fallbackChain[attempt % fallbackChain.length];
    
    try {
      const result = await executeWithProvider(provider, task, message, system, messages);
      return { ...result, provider, attempt: attempt + 1 };
    } catch (e) {
      console.warn(`Attempt ${attempt + 1} failed with ${provider}:`, e.message);
      
      if (attempt === retries - 1) {
        // Sista försöket — returnera partial result
        return {
          text: `[PARTIAL] Alla providers misslyckades. Senaste fel: ${e.message}`,
          error: true,
          provider: 'none',
          attempts: retries,
        };
      }
    }
  }
}
```

---

## Implementeringsplan

### Fas 1: Load Balancer (1-2 dagar)
- [ ] Skapa `api/load-balancer.mjs`
- [ ] Hälsokontroll var 30e sekund
- [ ] Viktad routing

### Fas 2: Smart Modellval (2-3 dagar)
- [ ] Uppdatera `selectModel` → `selectModelV2`
- [ ] Lägg till komplexitetsanalys
- [ ] Kontext-uppskattning

### Fas 3: Swarm (3-4 dagar)
- [ ] Skapa `api/swarm-orchestrator.mjs`
- [ ] Parallell exekvering
- [ ] Resultat-sammanställning

### Fas 4: Agent Memory (2 dagar)
- [ ] Skapa `api/agent-memory.mjs`
- [ ] Kontext-delning
- [ ] TTL-hantering

### Fas 5: Graceful Degradation (1-2 dagar)
- [ ] Uppdatera `intelligenceRouter`
- [ ] Retry-logik
- [ ] Partial results

---

## Förväntad Effekt

| Mått | Nu | Efter V2 |
|------|-----|----------|
| Tillgänglighet | 95% | 99.5% |
| Svarstid (medel) | 3s | 1.5s |
| Parallella tasks | 1 | 4-8 |
| Kontinuitet | 0% | 80% |
| Felhantering | hård | graceful |

---

## Nästa steg

1. **Godkänn planen** — vilka faser vill du köra?
2. **Prioritera** — vilken fas ger mest värde snabbast?
3. **Kör** — jag implementerar!