Agentrouting met Jev, LangChain en Vercel

In een AI-agent neemt Jev de kleine beslissingen tussen de LLM-calls door: welke tool of skill de agent gebruikt, welk model de volgende stap uitvoert, of de agent doorgaat of overdraagt, en of een toolcall te riskant oogt om uit te voeren. TypeSafe en zijn partners documenteren patronen voor intent-routing, modelkeuze, beslissingen over doorgaan of stoppen en risicocontrole van toolcalls. Een patroon voor beslissingen over retries is niet gedocumenteerd. Voordat u een van deze beslissingen van een LLM naar Jev verplaatst: speel uw eigen gelogde beslissingen opnieuw af via beide en vergelijk nauwkeurigheid, latency en kosten.

Deze gids bundelt wat de officiële documentatie van TypeSafe, LangChain, Vercel en Cloudflare laat zien, stand oktober 2026, en geeft duidelijk aan waar we een ontwerpidee beschrijven in plaats van een gedocumenteerde functie. Wij hebben Jev niet in een klantsysteem uitgerold. Achtergrond over het model zelf vindt u in wat Jev is.

Waar zitten routingbeslissingen in een agent?

De meeste agents draaien een loop: lees de taak en het laatste toolresultaat, bepaal de volgende stap, voer die uit, herhaal. Achter dat “bepalen” zitten meestal meerdere losse vragen die een LLM impliciet beantwoordt binnen één lange prompt. Een beslismodel maakt ze expliciet. De schets hieronder is leveranciersonafhankelijke pseudocode, geen code voor de Jev-API:

loop:
    state = compact summary of task, last tool result, step count
    answers = decision_model(state, [which_tool, needs_strong_model,
                                     tool_call_risky, should_continue])
    if any answer is below its confidence threshold:
        hand the step to an LLM or a person
    elif tool_call_risky is likely:
        refuse the call, or ask for approval
    else:
        run the chosen tool with the chosen model
    if not should_continue: stop

Twee punten uit de documentatie van TypeSafe bepalen dit ontwerp. Vragen moeten atomair zijn: brede oordelen splitst u op in meerdere vragen en combineert u in code. En de state moet kort zijn: Jev “heeft last van context rot” wanneer de state vol irrelevante details staat (Jev 1.13 jaggedness). Het volledige transcript meesturen is een slechte standaard; stuur mee wat de beslissing nodig heeft.

Routing van intents en tools

Het intent-routingpatroon van TypeSafe is het duidelijkste officiële voorbeeld. Een Choice-vraag classificeert het verzoek, een Score-vraag beoordeelt de complexiteit, en gewone code bepaalt waar het heen gaat: vragen over de orderstatus naar deterministische code, vragen over producten en retouren naar gespecialiseerde LLM-prompts, klachten naar een LLM of een mens, afhankelijk van de complexiteit. Bij lage confidence gaat het naar een mens. De routingfunctie zoals gepubliceerd:

def route_ticket(ticket_id, response):
    intent = response.answers["intent"]
    complexity = response.answers["complexity"]

    if intent.confidence < 0.5:
        # If we don't have enough confidence to classify, route to a human agent
        return route_to_human_agent(ticket_id)

    if intent.choice == "order_status":
        handle_order_status(ticket_id)
    elif intent.choice == "product_question":
        handle_with_llm(ticket_id, PRODUCT_SPECIALIST)
    elif intent.choice == "return_exchange":
        handle_with_llm(ticket_id, RETURNS_SPECIALIST)
    elif intent.choice == "complaint":
        low_confidence = complexity.confidence < 0.5
        # A higher complexity.score leans toward the "escalation needed" end of the scale.
        if complexity.score > 1 or low_confidence:
            # Too complex for safe automation, or we're not sure about the complexity; route to a human.
            route_to_human_agent(ticket_id)
        else:
            handle_with_llm(ticket_id, COMPLAINT_RESOLUTION)

Voor toolselectie in strikte zin heeft TypeSafe twee cookbooks. Het cookbook voor function calling zet een functienaam en de bijbehorende argumenten met een gesloten set waarden (literals en booleans) om in Choice- en Noul-vragen, één request per commando. Argumenten van het type integer, vrije tekst en datum houden hun standaardwaarde. Daar ziet u waar de aanpak ophoudt: Jev kiest de functie, maar vult geen open waarden in. Het cookbook voor skill-suggesties gebruikt twee Jev-requests om maximaal één van 182 skills te kiezen. In de eigen test van TypeSafe met 488 requests tegen Claude Haiku 4.5 daalde het aandeel keren dat de verkeerde skill werd geladen van 16,8% naar 7,3%, en het laden van een skill terwijl er geen paste van 9,8% naar 4,0%. Dat is een resultaat van de leverancier, op een taak die de leverancier koos.

Voor toolmenu's zijn twee grenzen van belang. Een Choice bevat maximaal 255 opties, en volgens de documentatie van TypeSafe “neigt Jev naar de optie die als eerste komt”. Heeft uw toollijst een vaste volgorde, test dan of de eerste tool vaker wint dan zou moeten.

Modelkeuze met LangChain

LangChain onderhoudt een package langchain-typesafe (alfa, 0.0.1a3 op het moment van schrijven) met een TypeSafeClassifier-Runnable en twee middlewareklassen die als experimenteel zijn gemarkeerd. ModelRouterMiddleware kiest welk model een stap uitvoert. Dit fragment komt van de providerpagina van LangChain:

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import (
    ModelChoice,
    ModelRouterMiddleware,
)

router = ModelRouterMiddleware(
    choices={
        "fast": ModelChoice(
            model="openai:gpt-5.6-terra",
            criteria="Direct lookups, extraction, and localized changes with explicit targets.",
        ),
        "powerful": ModelChoice(
            model="openai:gpt-6-astra",
            criteria="Architecture, novel root-cause reasoning, and high-stakes decisions.",
        ),
    },
    instructions="Choose the least costly model that can complete the task safely.",
)

agent = create_agent("openai:gpt-5.6-terra", middleware=[router])

Het volledige voorbeeld op die pagina gaat verder met agent.invoke(...) en leest de gekozen route uit result["model_route"].choice. Modelrouting is ook een van de toepassingen die Armin Ronacher, CTO van Earendil, noemde toen TechCrunch hem naar Jev vroeg. De rekensom is eenvoudig: de routercall is goedkoop, dus hij verdient zichzelf terug als hij genoeg stappen naar het goedkopere model stuurt zonder dat de uitkomsten eronder lijden. Of dat lukt, is precies wat u moet meten. Onze kostenvergelijking van LLM's geeft het prijsverschil tussen modelniveaus waar zo'n router op inspeelt.

Retries, doorgaan en escalatie

Hier is de documentatie mager, en dan loont het om precies te zijn. De officiële content van TypeSafe over retries gaat over transport: de SDK's proberen 429- en 529-fouten opnieuw met exponential backoff en respecteren retry-after. Er is geen officieel patroon om Jev te laten beslissen of een agent een mislukte stap opnieuw moet proberen.

Het dichtstbijzijnde gedocumenteerde voorbeeld is de doorgaan/stoppen-check van Vercel, uit de changelog van AI Gateway:

import { TypeSafeClient } from '@typesafe-ai/sdk';

const client = new TypeSafeClient({
  apiKey: process.env.AI_GATEWAY_API_KEY,
  baseURL: 'https://ai-gateway.vercel.sh/typesafe',
});

const result = await client.systemOne({
  state: 'The agent fixed the checkout bug and all tests pass.',
  questions: {
    continueWorking: {
      type: 'noul',
      instructions: 'Should the agent take another step?',
    },
  },
});

const shouldContinue = result.answers.continueWorking.noul >= 0.8;

Een retrybeslissing zou dezelfde vorm kunnen hebben; we presenteren dat uitdrukkelijk als ontwerpidee. Stel na een mislukte toolcall ja/nee-vragen, bijvoorbeeld of de fout tijdelijk lijkt en of dezelfde call met andere argumenten waarschijnlijk wel slaagt. Houd het aantal retries en de backoff in code; volgens de documentatie van Jev telt het model niet betrouwbaar. Zijn de antwoorden onzeker, escaleer dan in plaats van opnieuw te proberen.

Voor escalatiedrempels toont het confidence-routingpatroon van TypeSafe een flow voor bankieren via spraak met een confidence-ondergrens van 0,6 en automatische goedkeuring van een overboeking pas boven 0,85. Let op: Noul-antwoorden hebben geen confidence-veld. Bij ja/nee-vragen ligt de drempel dus op de kans zelf, zoals in de >= 0.8 van Vercel. Een onafhankelijke test van AY Automate stuurde onzekere gevallen bij een confidence onder 0,80 door naar GPT-5.6 Terra en kwam uit op 90,0% nauwkeurigheid tegen ongeveer 26% van de kosten van Terra. Dat zijn hun cijfers, op hun data; uw drempels moeten uit uw eigen data komen.

Risicocontrole van toolcalls

De experimentele AutoModeMiddleware(tools=[...]) van LangChain “vraagt naar de kans dat een toolcall riskant is of onvoldoende geautoriseerd”. Calls die als riskant worden beoordeeld, geven een fout-ToolMessage terug in plaats van te worden uitgevoerd. De waarschuwing van LangChain zelf is het herhalen waard: “Deze middleware weigert riskante calls. Ze vraagt niet om goedkeuring.” Heeft uw agent een goedkeuringsstap door een mens nodig, dan bouwt u die zelf.

De grotere kanttekening is prompt injection. Volgens de documentatie van Jev is de state data en “behandelt het model die standaard niet als vijandig”. VentureBeat beschreef een test van Octomind waarin een nepveld “pre-approved” de blokkeerkans voor rm -rf ~/.ssh verlaagde van 0,76 naar 0,48. Het standpunt van Pydantic, in hetzelfde artikel aangehaald, is het verstandige: een Jev-guard “hoort naast deterministische checks, niet in plaats ervan”. In de praktijk betekent dat: eerst allow- en denylists, validatie van argumenten en rechtencontroles in code, en Jev scoort de grijze zone die regels niet afdekken.

Integratienotities: LangChain, Vercel, Cloudflare en Pydantic

LangChain: langchain-typesafe wordt onderhouden in de langchain-ai-repository, maar zit in alfa, en beide middlewareklassen zijn experimenteel. Reken op wijzigingen in de API.
Vercel AI Gateway: het model heet typesafe-ai/jev en is bereikbaar via de TypeSafe-client met een gateway-base-URL (zoals hierboven), via een HTTP-endpoint /v1/evaluate of via de AI SDK met @ai-sdk/typesafe-ai. De pagina's van Vercel spreken elkaar tegen over de functienaam in de AI SDK (experimental_evaluate in de changelog, experimental_decide in de nieuwere integratiegids). Controleer dus de actuele documentatie voordat u code kopieert. De native API van de gateway noemt het ja/nee-type boolean met een veld .probability, waar TypeSafe noul gebruikt. Vercel zegt ook dat zijn agentframework eve Jev als standaardmodel voor evaluatie gebruikt.
Cloudflare Workers AI: de call is env.AI.run('typesafe/jev', { state, questions }) met het vraagschema van TypeSafe (modelpagina). Cloudflare noemt zero data retention en een contextvenster van 32.000 tokens, tegenover de 64k per request die TypeSafe opgeeft.
Pydantic AI: TypeSafeModel en TypeSafeProvider via de extra pydantic-ai-slim[typesafe], met uw eigen TypeSafe-key en zonder streaming (Pydantic).

Welke route u ook kiest: pin de modelversie (jev-1.13.0) vast zodra u drempelwaarden hebt afgesteld. De alias jev-latest gaat verschuiven.

Zo evalueert u Jev op uw eigen verkeer

Gepubliceerde benchmarks spreken elkaar tegen, en de eigen evaluaties van TypeSafe scoren tegen labels die door twee frontier-LLM's zijn gemaakt. Ze meten dus overeenstemming, geen juistheid. De enige cijfers die een overstap mogen bepalen, komen uit uw eigen verkeer. Een werkbare methode:

Haal gelogde beslissingen uit uw agenttraces: de state op het moment van beslissen, de keuze die uw huidige LLM maakte en, waar bekend, de uitkomst.
Label een steekproef met de hand, inclusief de lastige en dure gevallen. Een ander LLM als referentie gebruiken herhaalt het probleem van de benchmarks van leveranciers.
Schrijf elke beslissing uit als atomaire Jev-vragen. Reken op meerdere rondes; in de phishingtest die Beri.net samenvatte, veranderde het opsplitsen van één brede vraag in vijf het resultaat meer dan de keuze van het model.
Speel de steekproef offline af via Jev en via uw huidige LLM-baseline.
Vergelijk per type beslissing: nauwkeurigheid of macro-F1, de confusion matrix voor de dure fouten, en de kalibratie. Fit drempelwaarden per vraag; Beri.net vond de kalibratie van Jev zonder aanpassingen onbetrouwbaar.
Meet de dekking bij elke drempel: welk deel Jev zelfstandig afhandelt en welk deel escaleert naar het LLM.
Meet latency p50 en p95 vanuit de regio waar u uitrolt. De cijfers van de leverancier zijn gemeten vanaf de Amerikaanse westkust.
Bereken de kosten per 1.000 beslissingen, inclusief de LLM-calls voor geëscaleerde gevallen.
Voeg een adversariële set toe met geïnjecteerde instructies in de state, vooral voor vragen over toolrisico.
Draai in shadow mode op live verkeer voordat u overstapt, en houd het LLM-pad als fallback.

Ligt de uitkomst dicht bij elkaar, dan geven meestal het volume aan beslissingen en de kosten van elk type fout de doorslag. Het bredere kostenplaatje van agents staat in ons artikel over de kosten van AI-agentontwikkeling, en de bredere afwegingen in Jev vs LLM's.

Veelgestelde vragen

Werkt Jev met LangChain?

Ja. LangChain onderhoudt langchain-typesafe, met een TypeSafeClassifier-Runnable plus de experimentele ModelRouterMiddleware voor modelkeuze en AutoModeMiddleware voor risicocontrole van toolcalls. Het package zit in alfa.

Kan Jev tools kiezen voor een AI-agent?

Ja, bij gesloten keuzes. Het cookbook voor function calling van TypeSafe zet functienamen en argumenten met een gesloten set waarden om in Choice- en Noul-vragen; argumenten van het type integer, vrije tekst en datum moeten uit een andere bron komen. Eén Choice bevat maximaal 255 opties.

Heeft Jev een ingebouwd retrybeleid?

Alleen voor transportfouten: de SDK's proberen 429- en 529-responses opnieuw met backoff. Beslissen of een agent een mislukte stap opnieuw moet proberen, is geen gedocumenteerd Jev-patroon, al laat Vercel een verwante doorgaan/stoppen-check zien.

Is Jev veilig als enige bewaking van toolcalls?

Nee. Geïnjecteerde content in de state kan de antwoorden verschuiven, zoals een test van Octomind liet zien waarover VentureBeat berichtte. Gebruik Jev naast deterministische rechtencontroles, en houd er rekening mee dat de middleware van LangChain riskante calls weigert maar niet om goedkeuring vraagt.

Hoe stel ik confidence-drempels voor routing in?

Fit ze per vraag op uw eigen gelabelde data. De patronen van TypeSafe gebruiken in verschillende voorbeelden 0,5, 0,6 en 0,85, en het voorbeeld van Vercel gebruikt 0,8 op een Noul-kans, maar elke waarde is gekozen voor een specifiek voorbeeld.

De routinglaag bouwen

Een beslismodel verandert de vorm van een agent: routinglogica verhuist uit prompts naar getypeerde vragen, drempelwaarden en code die u kunt testen. Dat kan het systeem goedkoper in gebruik en beter controleerbaar maken, mits iemand eigenaar is van de evaluatie en de fallbacks. AI Superior ontwerpt en bouwt AI-agents en LLM-toepassingen voor B2B-klanten, met modelrouting, offline evaluatie en kostenbeheersing als onderdeel van de architectuur. Bekijk onze diensten voor LLM-deployment als u dit voor productie plant.

Agentrouting met Jev: toolselectie, modelkeuze en retries