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

// 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

// 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

// 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

// 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

// 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!