AI-agent handoff-mönster 2026: 6 arkitekturmönster med kod

TL;DR: när ska ni överhuvudtaget använda multi-agent?

Innan ni läser resten: multi-agent är sällan default-svaret. En välbyggd single-task agent slår ett halvfärdigt multi-agent-system på kostnad, tillförlitlighet och tid till produktion. Läs pillar-guiden AI-agenter: komplett guide för svenska företag 2026 för när enkla workflows är rätt.

Om ni ändå har verifierat att multi-agent behövs, då gäller resten av denna deepdive. Sex handoff-mönster med kod i LangGraph, failure modes, kostnadsimplikationer och beslutsmatris.

Vad är en agent-handoff? Definition och taxonomi

Sammanfattat

En agent-handoff är mekanismen genom vilken en autonom agent överför kontroll, kontext och ansvar till en annan agent i ett multi-agent-system. Handoff kan vara synkron (invoke-return), asynkron (message-queue) eller reactive (event-driven). Val av handoff-mönster påverkar latens, kostnad, observability och failure modes. Sex mönster dominerar 2026: supervisor, hierarchical team, tool-call, message-passing, blackboard och event-driven.

Tre variabler definierar varje handoff:

• Vem beslutar om handoff? Central orchestrator (supervisor, hierarchical) eller decentraliserad självorganisering (message-passing, event-driven).
• Vad överförs? Full state (deep handoff), bara relevant delmängd (scoped handoff) eller endast input och output (tool-call).
• Hur returnerar kontroll? Synkron return (blockerande), asynkron callback eller ingen return (fire-and-forget event).

Varje mönster nedan är en specifik kombination av dessa tre variabler, plus en preferens för när det passar bäst.

Mönster 1: Supervisor - en lead agent delegerar till specialister

Sammanfattat

Supervisor-mönstret har en lead agent som tar emot user-request, beslutar vilken specialist-agent som ska hantera vad, och orkestrerar deras output till slutresultat. Standard för nordisk enterprise 2026 eftersom det ger hög observability, enkelt att lägga in human-in-the-loop, kompatibelt med Artikel 12-loggning. Bäst för 3-6 specialist-agenter. Bygg med LangGraph create_supervisor eller Anthropic Claude Agent SDK Dynamic Workflows.

Supervisor är Alice Labs default-val för nordisk enterprise när multi-agent verkligen behövs. Fördelarna:

• Hög observability. All handoff går via supervisor, allt loggas på ett ställe. Enkelt för Artikel 12-audit.
• Human-in-the-loop-vänligt. Approval-gates läggs i supervisor-noden utan att röra specialisterna.
• Enkel att debugga. Linjär trace från input till output med tydliga delsteg.

Failure modes: supervisor-context växer snabbt när fler specialister adderas, vilket leder till kvalitetsförlust och kostnadsexplosion. Rekommenderad övre gräns 6 till 8 specialister. När ni behöver fler, byt till hierarchical team.

LangGraph-referens: create_supervisor-funktionen i langgraph-supervisor 2.x paketerar detta som färdig komponent. Anthropic Claude Agent SDK Dynamic Workflows implementerar samma mönster med Sonnet 4.6 som supervisor.

Se även LangGraph svenska guide för graf-baserad state machine-fördjupning.

Mönster 2: Hierarchical team - flera nivåer av supervisors

Sammanfattat

Hierarchical team har en top-level supervisor som delegerar till team-supervisors, som i sin tur delegerar till specialister. Rätt val när single supervisor växer över 6-8 specialister eller när uppgiften naturligt bryts i tema (research-team, writing-team, review-team). Latens ökar med varje nivå, observability blir mer komplex. Alice Labs använder detta för content-produktionsplattformar och research-orkestrering.

Hierarchical team är ett vertikalt skalat supervisor-mönster. Fördelen: minskad context per supervisor eftersom varje team-supervisor bara ser sin domän. Nackdelen: varje handoff adderar latens och möjligt kontext-läckage mellan lager.

När hierarchical passar:

• Uppgiften har naturliga sub-domäner (research, writing, review).
• Antalet specialister passerar 6-8 och en enskild supervisor tappar diskriminering.
• Ni har observability för multi-hop-tracing (Langfuse, LangSmith, Braintrust).

Alice Labs använder hierarchical för content-produktionsplattformar (research-team plus writing-team plus review-team) och för multi-vertikal kundservice-scenarier där varje vertikal har egen supervisor.

Failure mode att bevaka: orkestreringsblindhet där mellannivå-supervisor får ofullständig context och fattar suboptimala beslut. Motverka med explicit state-summering vid varje handoff.

Mönster 3: Tool-call handoff - agent som verktyg

Sammanfattat

Tool-call handoff exponerar en annan agent som ett verktyg i den kallande agentens tool-registry. Anropande agent skickar input, får output. Billigast i tokens av alla handoff-mönster eftersom endast function-call-signaturen kommuniceras. Bäst för välavgränsade delfunktioner utan behov av multi-hop-context. LangGraph, OpenAI Agents SDK och Anthropic Claude Agent SDK stödjer detta native via handoff-tools eller sub-agent-verktyg.

Tool-call handoff är den enklaste och billigaste formen av multi-agent. Den kallande agenten ser sub-agenten som ett vanligt verktyg. Ingen delad state, ingen komplex orkestrering.

När tool-call passar:

• Sub-agenten löser en välavgränsad delfråga (t.ex. hämta pris, sök lager, skicka mejl).
• Sub-agenten behöver inte se hela conversation-history.
• Ni vill hålla kostnad och latens minimalt.

När tool-call inte passar: sub-agenten behöver kontext-rik input (t.ex. hela kundhistoriken) eller producerar output som kräver post-processing av den kallande agenten som andra sub-agenter också behöver se.

OpenAI Agents SDK och Anthropic Claude Agent SDK stödjer detta native med handoff-tools respektive sub-agent-verktyg. CrewAI kallar det delegation. LangGraph har både sub-graphs och tool-nodes som täcker mönstret.

Mönster 4: Message-passing - asynkron kommunikation via kö

Sammanfattat

Message-passing kopplar agenter via meddelandekö (Kafka, Pub/Sub, Redis Streams). Varje agent konsumerar från sin kö, producerar till andra köer. Rätt val när användarupplevelsen är asynkron (bakgrundsjobb, batch processing) eller när sub-agenter kör olika hårdvara. Högre observability-krav, kräver ID-baserad tracing. Alice Labs använder detta för nattjobb-agenter och för scenarier med stor variation i sub-agent-latens.

Message-passing är den mest skalbara handoff-formen men också den med högsta operationell komplexitet. Fördelar:

• Decoupling. Sub-agenter kan uppdateras oberoende.
• Skalning. Kö-baserad backpressure hanterar burst-load naturligt.
• Heterogen infra. Vissa agenter kan köras på GPU-noder, andra på CPU, utan att synkront blockera varandra.

Nackdelar: latens är oförutsägbar, tracing kräver explicit correlation-id per meddelande, felhantering blir komplex (dead-letter queues, retry-backoff).

Praktisk stack: Google Pub/Sub eller AWS SQS för orkestrering, Kafka för hög-throughput scenarion, Redis Streams för lägre volym. LangGraph checkpointer plus Redis är en vanlig svensk enterprise-kombination.

Se även engelska guiden AI Agent Architecture Patterns för fler event-och message-mönster.

Mönster 5: Blackboard - delad state-buss där agenter läser och skriver

Sammanfattat

Blackboard är ett klassiskt AI-mönster från 1970-talet: alla agenter delar en gemensam state-buss (blackboard) och läser samt skriver till den enligt regler. Passar research- och analys-workflows där resultat aggregeras oberoende, som konkurrensanalys eller due-diligence. Kräver explicit state-schema för att inte drifta. Alice Labs använder det för research-agenter i strategisk M and A-analys.

Blackboard är den minst använda av de sex mönstren men i rätt kontext är den enastående kraftfull. Alla agenter läser och skriver till en central state-store. En controller inspekterar blackboarden och beslutar vilken agent som ska agera nästa.

När blackboard passar:

• Uppgiften är research- eller analys-tung där resultat aggregeras (konkurrensanalys, due diligence, litteraturöversikt).
• Agenter kan bidra oberoende utan strikt ordningsföljd.
• Ni behöver full transparens över alla mellansteg för audit eller review.

Nackdelar: state-schema måste designas noggrant, annars driftar strukturen och agenter börjar skriva till fel platser. Kräver validering vid varje skrivning (Pydantic-schema eller JSON-schema).

Alice Labs använder blackboard för strategiska M and A-agenter där researcher-, financial-, legal- och market-agenter alla skriver till en delad due-diligence-canvas över 24-48 timmar.

Mönster 6: Event-driven - reactive triggers och autonoma sub-agenter

Sammanfattat

Event-driven har ingen central orkestrator. Sub-agenter prenumererar på event-typer och triggas när matchande event uppstår. Passar system där triggers är externa (webhooks, IoT, database changes) eller där antalet agent-typer växer stort. Kräver stark observability och explicit event-schema. Alice Labs använder detta i intelligent document processing där olika agenter reagerar på nya dokumenttyper.

Event-driven är arkitekturen som skalar bäst över dussintals eller hundratals agent-typer, men även den som är svårast att debugga.

När event-driven passar:

• Triggers kommer externt (webhooks från CRM, IoT-sensorer, database changes, filsystem-uppdateringar).
• Antalet agent-typer växer så stort att central orchestration blir bottleneck.
• Sub-agenter kan agera helt asynkront utan behov av synkron return.

Failure mode att bevaka: infinite handoff-loopar där agent A triggar agent B som triggar agent A. Motverka med explicit generation-counter och loop-detection i event-bus (t.ex. via Redis SETEX med max-depth-kontroll).

Alice Labs använder event-driven i intelligent document processing för nordisk försäkring: nytt dokument utlöser klassifikations-agent, som utlöser extraktions-agent baserat på typ, som utlöser validation-agent, som utlöser approval-agent. Alla asynkront, alla observability via Langfuse plus egen correlation-id.

Alice Labs decision matrix: vilket mönster för vilken situation?

Sammanfattat

Alice Labs decision matrix från 100+ produktionsimplementationer: supervisor för 3-6 specialister med synkron UX, hierarchical team när supervisor sväller över 8 specialister eller domänen delas naturligt, tool-call för billiga välavgränsade delfrågor, message-passing för asynkrona bakgrundsjobb, blackboard för research- och analys-workflows, event-driven när triggers är externa eller antal agent-typer växer stort. Default för nordisk enterprise: supervisor plus tool-call i LangGraph.

Nedan är matrisen Alice Labs använder som utgångspunkt i alla nya multi-agent-uppdrag. Justera baserat på er UX, observability-mognad och kostnadsbudget.

Default för nordisk enterprise 2026: supervisor plus tool-call i LangGraph, med Anthropic Claude Agent SDK och MCP-verktyg som primär stack. Se CrewAI vs LangGraph vs AutoGen för fullt ramverks-perspektiv.

Kostnadsimplikationer: hur mycket dyrare blir multi-agent?

Sammanfattat

Supervisor-mönster ökar typiskt token-kostnad 3-8 gånger per user-request jämfört med single-agent, eftersom supervisor-prompten och specialist-kontexten upprepas. Hierarchical team lägger till ytterligare 2-3 gånger. Tool-call handoff är billigast (1,3-2 gånger). Blackboard är dyrast (5-15 gånger) på grund av upprepad state-läsning. Använd prompt caching, kontext-summering och tydliga tool-schemas för att hålla kostnaden nere.

Multi-agent är alltid dyrare än single-agent per user-request. Detta ska räknas in i business case från dag 1. Alice Labs typiska kostnads-multiplikatorer:

• Supervisor: 3-8 gånger single-agent-kostnad. Cachea supervisor-prompten för att komma ner mot 3.
• Hierarchical team: 6-20 gånger single-agent, beroende på antal nivåer.
• Tool-call handoff: 1,3-2 gånger. Billigast av multi-agent-mönster.
• Message-passing: 2-5 gånger. Kö-overhead är minimalt, LLM-kostnaden dominerar.
• Blackboard: 5-15 gånger. Delad state läses upprepade gånger. Aggressiv kontext-summering krävs.
• Event-driven: 2-6 gånger, beroende på hur ofta agenter re-triggas.

Cost-optimering per mönster: prompt caching (Anthropic, OpenAI, Google), kontext-summering mellan handoffs, tydliga tool-schemas för att slippa långa system-prompts, och aggressiv token-budget-alerting i regression-suite. Se AI-agent evals och testing-strategi för cost-eval-details.

Failure modes per mönster: infinite handoff, kontextförlust, orkestreringsblindhet

Sammanfattat

Varje handoff-mönster har karaktäristiska failure modes. Supervisor: context-överbelastning när fler specialister adderas. Hierarchical: orkestreringsblindhet i mellannivåer. Tool-call: förlorad rik state. Message-passing: dead-letter-hantering och correlation-id-läckage. Blackboard: state-schema-drift och race conditions. Event-driven: infinite handoff-loopar. Adressa med explicit loop-detection, generation-counter, kontext-summering och strikt state-schema.

Fältdata från Alice Labs 100+ nordiska produktionsagenter visar återkommande failure modes per mönster:

1. Supervisor context-överbelastning. När 8+ specialister adderas förlorar supervisor diskriminering. Lösning: dela upp i hierarchical eller summera specialist-output aggressivt före aggregering.
2. Orkestreringsblindhet. Mellannivå-supervisor i hierarchical teams får ofullständig context. Lösning: explicit state-summering vid varje handoff plus kritisk metadata bevaras.
3. Kontextförlust i tool-call. Sub-agent får bara function-call-input, missar konversationskontext. Lösning: designa scope så att sub-agent inte behöver det, eller byt mönster.
4. Dead-letter-hantering i message-passing. Failed messages hopar sig utan alarm. Lösning: DLQ-monitoring plus automatisk retry med exponential backoff.
5. Race conditions i blackboard. Två agenter skriver samtidigt till samma nod. Lösning: optimistic locking med version-nummer eller explicit turn-taking.
6. Infinite handoff-loopar i event-driven. Agent A triggar agent B som triggar agent A. Lösning: generation-counter i event och loop-detection i event-bus.

EU AI Act Artikel 12: hur handoff-val påverkar loggnings-krav

Sammanfattat

EU AI Act Artikel 12 kräver automatisk loggning av alla agent-actions med tillräcklig granularitet för spårbarhet. Supervisor och tool-call är enklast att auditera eftersom alla handoffs går via en central punkt. Message-passing, event-driven och blackboard kräver stark investering i correlation-id och trace-context-propagation för att uppnå samma granularitet. Välj enkelt mönster om ni är i högriskkontext (Annex III), eller investera aggressivt i observability.

EU AI Act Artikel 12 är kort men konkret: högriskklassade AI-system ska ha automatisk loggning av händelser genom hela livscykeln, tillräckligt granulär för att spåra individuella beslut och möjliggöra post-hoc-audit.

Praktisk konsekvens per handoff-mönster:

• Supervisor och tool-call. Central loggpunkt, enkel att auditera. Alice Labs default för högriskkontexter.
• Hierarchical team. Kräver trace-context-propagation genom alla nivåer, annars bryts kedjan.
• Message-passing. Correlation-id måste finnas på varje meddelande. Utan detta är rekonstruktion av beslutskedja omöjlig.
• Blackboard. Alla skrivningar måste vara timestamped och signerade med agent-id. Bygg som append-only log för att bevisa integritet.
• Event-driven. Varje event ska ha unique-id, parent-event-id och agent-id. OpenTelemetry-instrumentering är minimum.

Alice Labs rekommendation för högrisk-kontexter (Annex III): starta med supervisor eller tool-call för snabbare audit-ready produktionslansering. Investera i mer avancerade mönster först när observability-mognad är på plats.

Se EU AI Act 2026: checklista för svenska företag för fullt compliance-perspektiv.