LangChain v1 in 2026: de nieuwe stack om agents te bouwen (wat Reddit en X ervan vinden)

LangChain v1Hover to explore

Het grootste deel van 2023 en 2024 klonken de luidste meningen over LangChain op r/LangChain, r/LocalLLaMA en X/Twitter precies hetzelfde: 'geweldig voor demo's, pijnlijk in productie'. Wrappers op wrappers, abstracties die lekten zodra je een echte loop nodig had, en een roadmap die elke dinsdag een nieuwe chain leek uit te brengen. Met LangChain v1 (stabiel sinds eind 2025) is dat verhaal veranderd. Het framework heeft nu openlijk de vorm van een agent: één high-level instappunt, create_agent, een middleware-systeem, en LangGraph als standaard-runtime onder de motorkap.

Bronnen voor dit stuk zijn onder meer de officiële aankondiging van LangChain v1, de documentatie over LangChain-agents, terugkerende discussies op r/LangChain en r/LocalLLaMA, en threads van @LangChainAI en @hwchase17 op X. Patronen wegen zwaarder dan uitgekozen citaten.

1. Wat er in LangChain v1 echt veranderde

De belangrijkste verandering: LangChain is geen zak met chains meer. Het hoofdpakket draait nu om drie dingen:

• create_agent: één functie om een agent te bouwen die tools gebruikt, met model, tools, systeemprompt, structured output en middleware.
• Middleware: hooks voor en na model- en tool-calls (rate limiting, het afschermen van persoonsgegevens, menselijke goedkeuring, retries, samenvatten, guardrails).
• LangGraph-runtime: duurzame state met checkpoints onder elke agent, zodat pauzeren en hervatten, human-in-the-loop en time-travel-debugging standaard zijn in plaats van achteraf aangeplakt.

Oude onderdelen (LLMChain, AgentExecutor, initialize_agent, create_react_agent in de oude vorm) zijn nog te importeren, maar gemarkeerd als legacy. Nieuwe code hoort in langchain.agents en langchain.messages, met integraties van providers in langchain-openai, langchain-anthropic en verwante pakketten.

2. Een minimale v1-agent (de nieuwe 'hello world')

from langchain.agents import create_agent
from langchain.tools import tool

@tool
def get_weather(city: str) -> str:
    """Return the current weather for a given city."""
    return f"It's 24C and sunny in {city}."

agent = create_agent(
    model="anthropic:claude-sonnet-4-5",   # or "openai:gpt-5", "google:gemini-2.5-pro"
    tools=[get_weather],
    system_prompt="You are a concise travel assistant.",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Weather in Lisbon?"}]}
)
print(result["messages"][-1].content)

Drie dingen vallen op: het model is een string (LangChain regelt welke provider erbij hoort), tools zijn gewone Python-functies met de decorator @tool, en er is geen expliciete ReAct-prompt of parser. De agent-loop, het tool-calling-protocol en de message-reducers zitten allemaal in de runtime.

3. Structured output zonder tweede LLM-call

Een van de meest geupvote v1-features op r/LangChain is response_format. Geef een Pydantic-model mee en de agent levert een gevalideerd object op in dezelfde loop: geen extra parser, geen vervolgcall in de trant van 'haal dit nu als JSON eruit'.

from pydantic import BaseModel
from langchain.agents import create_agent

class TripPlan(BaseModel):
    city: str
    days: int
    must_do: list[str]

agent = create_agent(
    model="openai:gpt-5",
    tools=[get_weather],
    response_format=TripPlan,
)

out = agent.invoke({"messages": [
    {"role": "user", "content": "Plan 3 days in Lisbon."}
]})

plan: TripPlan = out["structured_response"]
print(plan.must_do)

4. Middleware: het deel waar mensen op X stilletjes enthousiast over zijn

Met middleware houdt v1 op een wrapper te zijn en begint het op een echt agent-framework te lijken. Je kunt inhaken op before_model, after_model, before_tool en after_tool, en herbruikbaar gedrag meeleveren zoals:

• SummarizationMiddleware: comprimeert lange geschiedenissen automatisch als de context groeit.
• HumanInTheLoopMiddleware: pauzeert voor destructieve tool-calls en wacht op goedkeuren, aanpassen of afwijzen.
• PIIMiddleware: maskeert e-mailadressen, namen of kaartnummers voordat ze bij de provider aankomen.
• ModelFallbackMiddleware: probeert het automatisch opnieuw met een goedkoper of reservemodel als het primaire model faalt.

from langchain.agents import create_agent
from langchain.agents.middleware import (
    HumanInTheLoopMiddleware,
    SummarizationMiddleware,
    PIIMiddleware,
)

agent = create_agent(
    model="anthropic:claude-sonnet-4-5",
    tools=[refund_order, send_email, query_db],
    middleware=[
        PIIMiddleware(strategy="redact"),
        SummarizationMiddleware(max_tokens_before_summary=12_000),
        HumanInTheLoopMiddleware(
            interrupt_on={"refund_order": True, "send_email": True}
        ),
    ],
)

Dit is het onderdeel dat LangChain, in ons eigen klantwerk en in recente threads op X, eindelijk productierijp laat voelen: de lastige productiezaken zijn samen te stellen in plaats van op promptniveau aan elkaar geplakt.

Standaard met stateHover to explore

5. Multi-agent: supervisor, swarm of gewoon subgraphs

Voor multi-agentopstellingen leunt LangChain op LangGraph plus twee kant-en-klare onderdelen die op Reddit steeds terugkomen:

• langgraph-supervisor: een router-agent bepaalt welke specialist (onderzoek, code, support) de volgende stap oppakt. Het beste bij een duidelijke rolverdeling.
• langgraph-swarm: gelijkwaardige agents geven elkaar het stokje door op basis van context. Voelt meer als de groepschats van CrewAI / AutoGen.
• Eigen subgraphs: stel gewoon de output van create_agent samen in een StateGraph als je volledige controle wilt over de edges en de vorm van de state.

6. Wat Reddit en X echt zeggen (de eerlijke mix)

Over de afgelopen maanden op r/LangChain, r/LocalLLaMA en de AI-engineeringhoeken van X komen deze thema's steeds terug:

• Positief: 'create_agent is wat het twee jaar geleden al had moeten zijn.' Middleware en structured output worden het vaakst genoemd als winst. LangSmith-traces 'werken gewoon', zonder gedoe.
• Gemengd: de opsplitsing in pakketten (langchain, langchain-core, langgraph, providerpakketten) laat nieuwkomers nog steeds struikelen. Migreren vanaf 0.x-code is 'grotendeels mechanisch, af en toe chirurgisch'.
• Kritisch: teams die volledig voor open-weight modellen gaan of extreem gevoelig zijn voor latency, kiezen nog steeds voor zelfgeschreven loops, Pydantic AI of de SDK's van providers. Het argument is niet meer 'LangChain is opgeblazen', maar 'ik heb geen graph nodig voor een pipeline van 3 stappen'. Terecht.
• Vergelijkingen: tegenover CrewAI wint LangChain op duurzaamheid, observability en strengheid bij tool-calling; CrewAI wint op het gemak van rollen en taken. Tegenover AutoGen wint LangChain op productieprimitieven; AutoGen op vrije multi-agentgesprekken. Tegenover de OpenAI Agents SDK wint LangChain op portabiliteit tussen providers en middleware/human-in-the-loop; de OpenAI SDK wint op de tijd tot de eerste demo als je volledig op één provider inzet.

'De interessante vraag in 2026 is niet meer "welk framework". Het is: met welk framework lever je dezelfde agent op drie providers, met een mens in de loop en een trace voor elke fout.'

7. De checklist voor founders voordat je je vastlegt

1. Kun je je agent beschrijven in één zin met een werkwoord en een uitkomst ('verwerkt een terugbetaling en mailt de klant')? Zo niet, stop dan en verklein eerst de scope.
2. Kies de minimale bouwstenen: create_agent + 2–5 tools + response_format. Sla middleware op dag één over.
3. Zet LangSmith aan vanaf de eerste commit. Elke latere optimalisatie (kosten, latency, eval) begint bij traces die je dan al hebt.
4. Voeg HumanInTheLoopMiddleware toe zodra een tool geld kan uitgeven, een bericht kan sturen of een databaserij kan wijzigen. Dit is de regel code met de meeste hefboomwerking in een productie-agent.
5. Grijp pas nadat een versie met één agent solide is naar supervisor of swarm. De meeste 'multi-agent'-problemen zijn eigenlijk slecht afgebakende toolproblemen.

De conclusie

LangChain v1 is de eerste versie waarin de vorm van het framework overeenkomt met hoe teams agents echt in productie bouwen: een loop die tools gebruikt met een graph eronder, hooks voor de saaie zaken (persoonsgegevens, goedkeuringen, samenvatten, retries) en hetzelfde codepad voor elke provider. Het gesprek op Reddit en X is verschoven van 'is LangChain een meme?' naar 'is je agent observeerbaar, herstelbaar en overdraagbaar?'. Voor founders die in 2026 een MVP uitbrengen, is dat een veel betere discussie.

Related Posts

Removing Expense Leakage Using Agentic Flow: The 2026 Founder's GuideApril 11, 2026

Gemma 4 by Google: What Founders Building AI MVPs Need to Know (2026)April 10, 2026

The Vibe Coding Trap: Why Thousands of AI Startups Are Paying $50K–$500K to Rebuild Their MVPsApril 2026