Build: Der Entscheidungs-Endpunkt

Jev ist weiterhin im Early Access. Wer keinen Schlüssel hat, kann es nicht aufrufen. Den Stand beschreibt Erste Schritte. Bauen kannst du trotzdem schon die Form, in die Jev später passt: eine Funktion, die ein Schema und einen StateState · engl. stateDer Zustand, den du einem Entscheidungsmodell schickst: Text, ein JSON-Objekt, eine Liste von Texten oder Bilder. Alle Fragen eines Aufrufs werden über denselben State beantwortet.Im Glossar bekommt und eine typisierte Entscheidung mit einer Zahl für die Sicherheit zurückgibt. Heute steckt ein gewöhnliches Sprachmodell dahinter. Später tauschst du es gegen das EntscheidungsmodellEntscheidungsmodell · engl. decision modelEin Modell, das Text liest und typisierte Antworten mit Wahrscheinlichkeiten zurückgibt: eine Option, eine Stufe, ja oder nein. Es schreibt keinen Text. Beispiel ist Jev, vom Hersteller „System One Model“ genannt.Im Glossar aus, ohne den Rest deines Codes anzufassen. Diese Lektion baut den Endpunkt, die nächste setzt einen Router davor.

Der Vertrag

Eine Funktion, decide(schema, question, state). Sie gibt ein Dictionary mit zwei Pflichtfeldern zurück:

• value passt zum Schema, zum Beispiel einer der Werte aus einer Enum-Liste.
• confidence liegt zwischen 0 und 1 und sagt, wie sicher die Antwort ist.

Dazu kommt ein drittes Feld, usage, mit den verbrauchten Tokens. Für die Entscheidung selbst braucht es niemand. Du brauchst es später, um Kosten zu vergleichen.

Das bildet ab, was Jevs Fragetypen liefern: eine typisierte Antwort und eine Wahrscheinlichkeit. Bei Choice-Fragen ist das die Wahrscheinlichkeit der gewählten Option, wie in Jev im Agenten-Stack beschrieben. Das Feld confidence aus Jevs Antwort misst etwas anderes. Wie Jev zu seiner Zahl kommt, bildet der Vertrag nicht nach. Er legt nur fest, was dein Code bekommt.

Warum Self-Consistency

Für eine Zahl zur Sicherheit aus einem Sprachmodell gibt es zwei ehrliche Wege. Der direkte wären Token-Wahrscheinlichkeiten, sogenannte Logprobs. Die Messages-API von Claude liefert keine, in der API-Referenz taucht das Feld nicht auf (Stand: Nov. 2026).

Es bleibt Self-ConsistencySelf-ConsistencyDieselbe Frage mehrmals an ein Sprachmodell stellen, die häufigste Antwort nehmen und den Anteil ihrer Stimmen als Konfidenz verwenden. Misst, wie stabil das Modell antwortet, und sagt wenig darüber, ob die Antwort stimmt.Im Glossar: Du stellst dieselbe Frage mehrmals, nimmst die Mehrheitsantwort und verwendest den Anteil der Stimmen als Konfidenz. Das ist grob. Es misst aber etwas Echtes, nämlich wie stabil das Urteil des Modells bei genau dieser Eingabe ist.

Der Code

Die strukturierte Ausgabe läuft über output_config mit einem JSON-Schema. Sie ist allgemein verfügbar und braucht keinen Beta-Header. Fünf Stichproben gehen parallel an Haiku 5.5, das kleinste aktuelle Claude-Modell. Du brauchst pip install anthropic (getestet mit 2.8.0) und die Umgebungsvariable ANTHROPIC_API_KEY.

# decision.py – der Stand-in: Self-Consistency mit Haiku
import json
from collections import Counter
from concurrent.futures import ThreadPoolExecutor

import anthropic  # pip install anthropic

client = anthropic.Anthropic()  # liest ANTHROPIC_API_KEY
MODEL = "claude-haiku-5-5"      # klein und schnell: dieser Platz ist System-One-Arbeit
SAMPLES = 5


def _ask_once(schema: dict, question: str, state: str) -> tuple[str, int, int]:
    response = client.messages.create(
        model=MODEL,
        max_tokens=256,
        thinking={"type": "disabled"},  # eine Klassifikation, kein Nachdenken
        messages=[{"role": "user", "content": f"{question}\n\nState:\n{state}"}],
        output_config={
            "effort": "low",
            "format": {
                "type": "json_schema",
                "schema": {
                    "type": "object",
                    "properties": {"value": schema},
                    "required": ["value"],
                    "additionalProperties": False,
                },
            },
        },
    )
    text = next(b.text for b in response.content if b.type == "text")
    value = json.dumps(json.loads(text)["value"], sort_keys=True)  # normalisiert fürs Abstimmen
    return value, response.usage.input_tokens, response.usage.output_tokens


def decide(schema: dict, question: str, state: str) -> dict:
    with ThreadPoolExecutor(max_workers=SAMPLES) as pool:
        futures = [pool.submit(_ask_once, schema, question, state) for _ in range(SAMPLES)]
        results = [f.result() for f in futures]
    winner, votes = Counter(r[0] for r in results).most_common(1)[0]
    return {
        "value": json.loads(winner),
        "confidence": votes / SAMPLES,
        "usage": {"input": sum(r[1] for r in results), "output": sum(r[2] for r in results)},
    }


if __name__ == "__main__":
    print(decide(
        schema={"type": "string", "enum": ["billing", "technical", "account", "other"]},
        question="Welches Team soll dieses Support-Ticket bearbeiten?",
        state="Meine Karte wurde diesen Monat zweimal für dieselbe Rechnung belastet.",
    ))

Was der Testlauf zeigte

Wir haben 20 deutsche Support-Tickets mit eigenen Labels durch decide geschickt, mit vier Routen zur Auswahl: Abrechnung, Passwort, Kündigung und Sonstiges (Stand: 13. Nov. 2026). Eine Entscheidung brauchte 0,8 bis 1,8 Sekunden. Die fünf Aufrufe zusammen verbrauchten rund 1.440 Eingabe- und 50 Ausgabe-Tokens. Bei 0,10 und 0,50 US-Dollar pro Million Tokens sind das etwa 0,17 US-Dollar für tausend Entscheidungen.

Auffälliger war die Konfidenz. 19 von 20 Tickets bekamen 1,0, also fünf gleiche Stimmen. Darunter war „Ich komme nicht mehr in mein Konto, und abgebucht wurde trotzdem“. Das Ticket passt zu zwei Routen. Haiku wählte fünfmal Abrechnung, unser Label sagt Passwort. Fünf gleiche Stimmen kommen also auch bei einem mehrdeutigen Ticket vor. Sie messen, wie stabil das Modell antwortet, und sagen wenig darüber, ob es recht hat.

Dazu kommt die grobe Auflösung. Bei fünf Stichproben und vier Optionen hat die Mehrheit mindestens zwei Stimmen. Die Konfidenz kann deshalb nur 0,4, 0,6, 0,8 oder 1,0 sein. Mehr Stichproben machen die Skala feiner und den Aufruf teurer. Der Rechner zeigt, wie sich das verschiebt. Er nimmt die gemessenen 290 Eingabe- und 10 Ausgabe-Tokens pro Stichprobe.

Wie der Stand-in von Jev abweicht

Sieh dir die Lücke nüchtern an. Jev rechnet nicht Token für Token und beantwortet alle Fragen einer Anfrage in einem Durchgang. Unser Stand-in macht fünf Generierungen pro Frage. Jevs Zahl ist laut Hersteller eine kalibrierte Wahrscheinlichkeit, trainiert mit dem Verfahren RLCD. Unsere Zahl ist ein Stimmenanteil mit vier möglichen Werten. Über KalibrierungKalibrierung · engl. calibrationWie gut eine Konfidenz zur tatsächlichen Trefferquote passt. Gut kalibriert heißt: Von allen Antworten mit 0,9 Konfidenz sind etwa neun von zehn richtig.Im Glossar sagt sie nichts.

Auch bei Zeit und Geld liegt der Stand-in deutlich hinten. Er braucht rund eine Sekunde, Jev in unserem Test 150 Millisekunden. Er kostet pro Entscheidung etwa zwölfmal so viel. Erhalten bleibt beim Tausch der Vertrag. Genau von ihm hängt dein übriger Code ab.

Prüf dich selbst