ReAct agent-pattern förklarat: guide 2026

Vad är ReAct? Loop-mekaniken och historiken

ReAct står för Reasoning plus Acting. Det är ett prompt-mönster för LLM-agenter som Shunyu Yao och kollegor vid Princeton och Google Research introducerade i pappret ReAct: Synergizing Reasoning and Acting in Language Models (arXiv:2210.03629, oktober 2022).

Grundcykeln:

1. Thought. LLM producerar en naturlig-språk-tanke om vad som ska göras: "Jag behöver kolla fakturans belopp innan jag kan svara kunden".
2. Action. LLM väljer ett verktyg och parametrar: lookup_invoice(number="INV-2026-042").
3. Observation. Verktyget körs och returnerar ett resultat: {"amount": 12500, "status": "paid"}. Observationen läggs till context.
4. Nästa Thought. LLM resonerar över observationen och genererar nästa steg. Loopen fortsätter tills målet nås eller max-iterations-gränsen triggas.

Insikten från pappret 2022 var att kombinera resonemang och handling i samma LLM-anrop är dramatiskt mer effektivt än att göra dem separat. Ren chain-of-thought (bara resonera) kan inte agera. Ren tool-use (bara agera) kan inte planera. ReAct löser båda samtidigt.

Från 2023 blev ReAct fundamentet för LangChain AgentExecutor, LlamaIndex ReActAgent, ursprungliga versionerna av AutoGen och tidiga versioner av CrewAI. Moderna ramverk som Claude Agent SDK, LangGraph och Pydantic AI implementerar ReAct-loopen men gömmer den bakom mer abstraherade API:er. För internationella team finns samma genomgång på engelska i vår artikel om vad en ReAct-agent är.

För bredare kontext, se pillar-guiden AI-agenter: komplett guide för svenska företag 2026 och ramverks-jämförelse Bästa AI-agent-ramverken 2026.

ReAct vs chain-of-thought vs Reflexion: när använda vad

Sammanfattat

Chain-of-thought (CoT) är ren resonemang utan handling – rätt för matematik och logik-problem utan externa verktyg. ReAct kombinerar resonemang med verktygsanrop – rätt för uppgifter som kräver aktuell data eller externa actions. Reflexion adderar en reflektions-fas efter varje handling där LLM utvärderar om resultatet var bra – rätt för kritiska scope där självkorrektion är värdefull.

Praktisk regel för svenska team: börja med ReAct som default. Om agenten kräver 15+ steg, migrera till Plan-and-Execute. Om agenten opererar i kritiska scope (bank, försäkring, sjukvård), addera Reflexion. Tree-of-Thought är sällan motiverat utanför spel och sökning.

ReAct-kod-exempel: Python och LangGraph

Sammanfattat

Uppgift: agent som svarar på kundfråga om fakturastatus. Verktyg: lookup_invoice, escalate_to_human. LangGraph-implementation: en ReAct-nod som bindar tools och löper Thought-Action-Observation tills LLM producerar final answer. 40 rader kod. Alice Labs default för ReAct-agenter i svensk enterprise: LangGraph plus Claude Sonnet 4.5 plus MCP-verktyg.

Uppgift: en agent som svarar på kundfråga om fakturastatus. Verktyg: lookup_invoice och escalate_to_human. Implementation i LangGraph med Claude Sonnet 4.5:

from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode, tools_condition
from langchain_anthropic import ChatAnthropic
from langchain_core.tools import tool
from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

@tool
def lookup_invoice(invoice_number: str) -> dict:
    """Slår upp fakturastatus från Fortnox."""
    return {"invoice": invoice_number, "amount": 12500, "status": "paid"}

@tool
def escalate_to_human(reason: str) -> str:
    """Skickar ärendet till mänsklig handläggare med anledning."""
    return f"Escalated: {reason}"

tools = [lookup_invoice, escalate_to_human]

llm = ChatAnthropic(model="claude-sonnet-4-5").bind_tools(tools)

class State(TypedDict):
    messages: Annotated[list, add_messages]

def call_model(state):
    return {"messages": [llm.invoke(state["messages"])]}

graph = StateGraph(State)
graph.add_node("agent", call_model)
graph.add_node("tools", ToolNode(tools))
graph.set_entry_point("agent")
graph.add_conditional_edges("agent", tools_condition)
graph.add_edge("tools", "agent")
app = graph.compile()

for chunk in app.stream({
    "messages": [("user", "Är faktura INV-2026-042 betald?")]
}):
    print(chunk)

Det som händer under huven är exakt ReAct-loopen från Yao et al 2022:

1. Thought (LLM). "Jag behöver slå upp fakturans status för att svara."
2. Action. lookup_invoice(invoice_number="INV-2026-042")
3. Observation. {"amount": 12500, "status": "paid"}
4. Thought. "Fakturan är betald, jag kan svara kunden."
5. Final answer. "Ja, faktura INV-2026-042 är betald (12 500 SEK)."

LangGraph tools_condition-helpern kollar om LLM:et producerade ett verktygsanrop; om ja går flödet till tools-noden och sedan tillbaka till agenten; om nej går flödet till END. Det är hela ReAct-mönstret.

Se LangGraph guide för svenska team för djupare LangGraph-mönster.

När ReAct fungerar bra: 3-8 steg, väldefinierade verktyg

Sammanfattat

ReAct fungerar bäst för uppgifter med 3-8 steg, väldefinierade verktyg (max 5-8 tool-alternativ), tydliga mål och strukturerad observation-format. Vanliga svenska use-cases: kundservice-agent, faktura-lookup, sales-research, dokument-classification. 60 procent av Alice Labs produktionsagenter använder ren ReAct som fundament.

ReAct har fyra kriterier för att fungera bra i produktion:

1. Kort horisont (3-8 steg). När loopen är kort ackumuleras få fel. LLM:et kan hålla hela kontexten i huvudet.
2. Väldefinierade verktyg. Max 5-8 tool-alternativ. Ju fler verktyg, desto större risk för verktyg-hallucination (LLM väljer fel verktyg eller uppfinner parametrar).
3. Tydliga mål. Målet ska vara enkelt att verifiera. "Är fakturan betald?" är tydligt. "Optimera vårt sales-workflow" är inte.
4. Strukturerad observation-format. Verktyg ska returnera typade, förutsägbara resultat. Undvik verktyg som returnerar 10 sidors HTML eller ostrukturerad text.

Svenska use-cases där ReAct är rätt val enligt Alice Labs fältdata 2024-2026:

• Kundservice-agent (fakturafrågor, orderstatus, returer)
• Sales-research (företagsinfo, kontaktuppgifter, kvalificering)
• Dokument-classification (fakturor, avtal, ärenden)
• Data-lookup och rapportering (SQL, Snowflake, BI)
• Fakturamatchning i Fortnox eller Visma

Failure modes: kontextinflation, verktyg-hallucination, oändliga loopar

Sammanfattat

Fyra vanligaste failure modes i ReAct-produktion. Kontextinflation: varje Thought-Action-Observation läggs till context, tokens exploderar. Verktyg-hallucination: LLM anropar verktyg som inte finns eller med fel parametrar. Oändliga loopar: LLM väljer samma verktyg om och om. Long-horizon-collapse: kvalitet dalar dramatiskt efter 15+ steg. Alla adresseras av moderna alternativ men kräver design-medvetenhet i ReAct.

ReAct i produktion har fyra failure modes ni ska designa mot:

1. Kontextinflation. Varje Thought-Action-Observation läggs till context. En 15-stegs loop kan konsumera 30 000 tokens bara i mellansteg, vilket dramatiskt driver upp cost och latens. Motverkas med context-summering efter var femte steg eller migration till Plan-and-Execute.
2. Verktyg-hallucination. LLM:et anropar ett verktyg som inte existerar eller med felaktiga parameter-typer. Motverkas med strict Pydantic- eller JSON-schema-validering, tydliga tool-beskrivningar och att hålla antalet verktyg lågt.
3. Oändliga loopar. LLM väljer samma verktyg med samma parametrar om och om. Motverkas med max-iterations-gräns (default 10-15 för Alice Labs), duplicate-detection i orchestrator och reflection-fas som bryter loopen.
4. Long-horizon-collapse. Efter 15+ steg dalar kvalitet dramatiskt. LLM tappar tråd, missar dependencies mellan steg, upprepar arbete. Motverkas med Plan-and-Execute-migration eller att uppgiften dekomposeras via multi-agent.

EU AI Act-implikation: Artikel 15 (robusthet) kräver att systemet ska hantera edge cases utan att fallera. Failure modes ovan ska adresseras och dokumenteras i teknisk fil för IMY. Alice Labs standard för svenska högrisk-agenter: max-iterations 10, context-summering efter 5 steg, duplicate-detection, Langfuse för loop-detection i produktion.

Moderna alternativ 2026: Plan-and-Execute, ReWOO, Reflexion, Tree-of-Thought

Sammanfattat

Fyra moderna alternativ 2026. Plan-and-Execute: planerings-agent skapar plan först, executor-agent kör steg-för-steg. ReWOO: skiljer planering från exekvering för lägre token-kostnad. Reflexion: adderar reflektions-fas efter varje handling. Tree-of-Thought: söker i lösningsrymden med backtracking. Alice Labs 2026: Plan-and-Execute för long-horizon, Reflexion för kritiska scope, ReAct som default.

Fyra moderna alternativ som adresserar ReAct:s failure modes:

• Plan-and-Execute. En planerings-agent skapar en plan (5-15 steg) först. En executor-agent kör steg-för-steg. Om ett steg misslyckas kan planeraren revidera. Rätt för long-horizon (15+ steg). Referens: LangGraph-tutorial och Wang et al 2023.
• ReWOO (Reasoning WithOut Observation). Skiljer planering från exekvering och kör dem asynkront. Observations skickas inte tillbaka till planeraren, bara till aggregator-steg. 40-60 procent lägre token-kostnad vs ReAct för samma uppgift. Rätt för kostnadskänsliga workflows. Referens: Xu et al 2023.
• Reflexion. ReAct plus en reflektions-fas efter varje handling där en separat LLM-call utvärderar om resultatet var bra och skickar tillbaka feedback. 20-40 procent bättre task-success rate men 2-3x token-kostnad. Rätt för kritiska scope (bank-KYC, HR-screening, sjukvård). Referens: Shinn et al 2023.
• Tree-of-Thought. Utforskar flera lösningsvägar parallellt och backtrackar när en gren misslyckas. 5-10x token-kostnad. Rätt för sökning, spel och planering där lösningsrymden är stor. Referens: Yao et al 2023.

Alice Labs val 2026:

• ReAct. Default för alla enkla-till-medelkomplexa agenter.
• Plan-and-Execute. När horisont är 15+ steg eller uppgiften kräver flera parallella spår.
• Reflexion. När scope är EU AI Act-högrisk och självkorrektion är kritisk.
• ReWOO. När token-kostnad är kritisk och observations inte behöver influera planering.
• Tree-of-Thought. Sällan. Bara för sökning eller spel-liknande use-cases.

Migration från ren ReAct till moderna alternativ

Sammanfattat

Migration från ReAct till Plan-and-Execute tar typiskt 1-2 dagar per agent i LangGraph. Verktygslagret återanvänds. Orkestreringen får två noder istället för en (planerare, executor). Migration till Reflexion är enkel additiv: lägg till en reflection-nod efter tool-nod. Migration till ReWOO kräver mer arbete (asynkront exekverings-lager). Alice Labs har genomfört 20+ migrationer sedan 2024.

Migration är oftast enklare än att skriva om från noll. Alice Labs erfarenhet 2024-2026:

1. ReAct till Plan-and-Execute i LangGraph. 1-2 dagar per agent. Verktygslagret återanvänds. Orkestreringen får två noder: planerare (LLM som producerar plan-JSON) och executor (LLM som exekverar steg-för-steg). Vanligaste migration i svensk enterprise.
2. ReAct till Reflexion. 0,5-1 dag per agent. Lägg till en reflection-nod efter tool-nod. LLM utvärderar om resultatet var bra och genererar eventuellt feedback. Enklaste migrationen.
3. ReAct till ReWOO. 3-5 dagar per agent. Kräver asynkront exekverings-lager och aggregator. Mer komplex migration men betalar tillbaka i token-cost för hög-trafik-agenter.
4. ReAct till Tree-of-Thought. Sällan värt migrationen utanför spel/sökning. 5-10 dagar per agent.

Alice Labs har genomfört 20+ ReAct-till-alternativ-migrationer sedan 2024. Se LangGraph-guiden för LangGraph-specifika mönster.

Alice Labs val: när ReAct kvarstår i produktion 2026

Sammanfattat

Alice Labs kör ren ReAct-loop som fundament i cirka 60 procent av 100+ produktionsagenter 2026. Använder ReAct för enkla-till-medelkomplexa uppgifter (3-8 steg, väldefinierade verktyg). Migrerar till Plan-and-Execute för 15+ steg, Reflexion för kritiska scope och ReWOO för kostnadskänsliga workflows. Ramverk: LangGraph eller Claude Agent SDK plus MCP-verktyg plus Langfuse-observability.

Alice Labs val 2026: ReAct kvarstår som default för enkla-till-medelkomplexa svenska produktionsagenter. Cirka 60 procent av 100+ produktionsagenter använder ren ReAct som fundament. Vår standardstack:

1. Orkestrering. LangGraph eller Claude Agent SDK. Båda gömmer ReAct-loopen bakom clean API men gör den enkel att inspektera och modifiera.
2. LLM. Claude Sonnet 4.5 som default. GPT-4.1 där Azure OpenAI Sweden Central-integration är krav. Gemini för multimodala use-cases.
3. Verktyg. Alla externa integrationer (Fortnox, Visma, Salesforce, Zendesk, Snowflake) exponeras som MCP-servers för återanvändning över agent-projekt.
4. Observability. Langfuse (open source, EU-hostad i Sweden Central) för multi-hop-tracing, loop-detection och regressionstester.
5. Failure-mode-skydd. Max-iterations 10, context-summering efter 5 steg, duplicate-detection, JSON-schema-validering på alla tool-anrop.

När migrerar vi bort från ren ReAct? Tre triggers:

• Horisont växer till 15+ steg → migrera till Plan-and-Execute.
• Scope blir EU AI Act-högrisk (bank-KYC, HR-screening, sjukvård) → addera Reflexion-fas.
• Token-kostnad blir dominerande → migrera till ReWOO för hög-trafik-agenter.

Boka arkitekturmöte via AI-agenter för svenska företag så matchar vi rätt agent-mönster mot ert use-case och EU AI Act-scope.