habe eine Zeile wie ESCALATION_THRESHOLD = 0.90. Darüber agiert der Agent. Darunter wird ein Mensch angepingt.

Es ist einfach. Es ist abstimmbar. Es gibt jedem das Gefühl, dass die Autonomie unter Kontrolle ist.

Aber es ist nicht die richtige Lösung.

Das Replace ist keine bessere Nummer. Der Repair stellt fest, dass die Eskalationsschwelle überhaupt nie ein Prozentsatz battle. Es ist ein Preis.

Beginnen Sie mit der falschen Frage

Die meisten Groups stellen eine Fähigkeitsfrage. Kann der Agent das SQL schreiben? Kann die Rückerstattung erfolgen? Wenn ja, lassen Sie es laufen.

Aber etwas tun zu können und sich dafür zu entscheiden, es alleine zu tun, sind verschiedene Themen. Beim zweiten geht es eigentlich um die Entscheidung selbst: Was kostet ein Fehler und was kostet es, stattdessen einen Menschen einzubeziehen?

Das ist die wahre Wahl. Wenn der Agent handelt, riskieren Sie die Kosten eines Fehlers. Wenn Sie eskalieren, zahlen Sie für die Zeit eines Menschen, unabhängig davon, ob der Agent Recht hatte oder nicht.

Geben Sie Zahlen an und der Vergleich ist quick peinlich einfach. Eine Annahme zunächst: Der Mensch bekommt eskalierte Tickets richtig. Das lockern wir später. Handeln Sie vorerst allein, wenn:

(1 - p) * cost_of_error  <  cost_of_escalation

Dabei ist p die Wahrscheinlichkeit, dass der Agent Recht hat. Neu angeordnet, eskalieren, wann immer:

p  <  1 - (cost_of_escalation / cost_of_error)

Der Wert auf der rechten Seite ist der tatsächliche Schwellenwert. Beachten Sie, worauf es ankommt. Nicht das Modell. Keine Police aus einer Werkstatt. Nur ein Verhältnis zwischen zwei Kosten. Wenn Fehler günstig sind, ist die Schwelle niedriger und der Agent kann häufiger handeln. Wenn Fehler teuer sind, ist die Hemmschwelle höher und selbst ein selbstbewusster Makler sollte um Hilfe bitten.

Bei einem festen Grenzwert wird davon ausgegangen, dass das Verhältnis für jede Entscheidung, mit der der Agent jemals konfrontiert wird, gleich ist. Das ist selten.

Dieser Ansatz basiert auf Chows Ablehnungsregel aus dem Jahr 1970, die die Grundlage der heutigen Forschung zum Lernen des Aufschiebens bildet. Alte Ideen altern intestine, wenn sie richtig sind.

Zwei Tickets

Der einfachste Weg, dies zu zeigen: Help-Ticket-Triage. Ein Agent liest eingehende Tickets und löst sie entweder oder leitet sie an eine Particular person weiter. Die Zahlen hier sind für das Argument erfunden, aber sie hängen zusammen.

Eine routinemäßige Rückerstattungsanfrage. Kleine Menge, klare Richtlinien. Wenn der Agent es vermasselt, ist die Bereinigung ein Folgeticket und eine Kulanzgutschrift. Nennen wir es 15 £. Eskalierende Verbrennungen erfordern etwa drei Minuten der Zeit eines Spezialisten. Nennen Sie das 4 £.

Der Schwellenwert liegt bei 1 minus 4/15. Ungefähr 0,73.

Wenn der Agent additionally zu 90 % überzeugt ist, sollte er eindeutig handeln. Eine Eskalation würde 4 £ kosten, um nur 1,50 £ des erwarteten Fehlers zu vermeiden. Wenn Sie es laut aussprechen, würde niemand diesen Commerce tätigen, aber ein fester Cutoff führt ihn automatisch den ganzen Tag über durch.

Jetzt eine mögliche Kontoübernahme. Ein Kunde meldet eine Passwortänderung, die er nicht vorgenommen hat. Wenn der Agent dies als Routine betrachtet, ist der Nachteil kein Vorteil. Es geht um Betrugsverluste, Abhilfemaßnahmen, regulatorische Risiken und einen Kunden, der nie wieder zurückkommt. Setzen Sie konservative 2.000 £ ein. Die Eskalation kostet immer noch 4 £.

Der neue Schwellenwert beträgt 1 minus 4/2000 oder 0,998. In der Praxis bedeutet das, dass Sie immer eskalieren sollten. Bei einem Vertrauensverhältnis von 90 % birgt das alleinige Handeln des Maklers ein Risiko von 200 £ an erwarteten Kosten, verglichen mit nur 4 £ für eine Eskalation. Es ist fünfzigmal günstiger, es abzugeben.

Gleicher Agent. Gleiche 90 %. Gegenüberliegende richtige Antworten. Die 90 %-Regel besagt, dass in beiden Fällen gehandelt werden muss, und im zweiten Fall werden stillschweigend 196 £ professional Ticket verbrannt, um jemandem drei Minuten zu sparen.

Diese Beobachtung landet normalerweise im Gespräch.

Eine ehrliche Falte. Das Beispiel geht davon aus, dass der Agent weiß, welches Ticket er besitzt. Bei der echten Triage ist das die Unsicherheit. Wenn der Agent zu 90 % sicher ist, dass es sich bei einem Ticket um eine routinemäßige Rückerstattung handelt, könnte es sich bei einem Teil der restlichen 10 % um eine verdeckte Übernahme handeln. Gewichten Sie additionally die Fehlerkosten nach dem, was das Ticket sein könnte, und nicht nach dem, was es wahrscheinlich ist. Bewerten Sie es im Zweifelsfall als die schlechteste believable Klasse. Billig aussehende Tickets sind genau dort, wo sich teure Fehler verstecken.

Der Haken

All diese Arithmetik beruht auf einer Annahme. Wenn der Agent 90 % sagt, hat er in etwa 90 % der Fälle Recht.

Das ist Kalibrierung und nicht dasselbe wie Vertrauen. Vertrauen ist eine Zahl, die das Modell ausgibt. Bei der Kalibrierung geht es darum, ob die Zahl etwas bedeutet.

Geben Sie das in die Regel ein und beobachten Sie, wie sie bricht. Wenn 0,95 angegeben ist, bedeutet dies tatsächlich 0,70, Ihre erwarteten Fehlerkosten sind sechsmal so hoch wie die arithmetische Berechnung. Der Schwellenwert, den Sie so sorgfältig festgelegt haben, ist Fiktion. Sie managen das Risiko nicht mehr. Sie waschen es durch eine Zahl, die wie eine Wahrscheinlichkeit aussieht, aber keine ist.

Überprüfen Sie additionally vorher die Nummer. Protokollieren Sie jede Entscheidung mit der angegebenen Sicherheit. Bucket nach Konfidenzband, professional Entscheidungsklasse. Vergleichen Sie die angegebene mit der tatsächlichen Genauigkeit in jedem Eimer. Wenn der Agent 90 % sagt und 78 % erreicht, haben Sie Ihre Korrektur gefunden: Ordnen Sie eins dem anderen zu, bevor irgendetwas den Schwellenwert berührt. Die Anpassung erfolgt durch isotonische Regression oder Platt-Skalierung.

Hier stechen zwei Particulars hervor. Agenten sind in der seltenen, risikoreichen Klasse oft am schlechtesten kalibriert, gerade weil sie selten ist. Das ist die Klasse, die Ihren extremen Schwellenwert trägt, sodass ein globaler Durchschnitt den entscheidenden Fehler verbirgt. Und die Karte verschiebt sich, wenn sich der Ticketmix ändert, additionally messen Sie sie nach einem Zeitplan neu. Die Technik zählt weniger als die Gewohnheit. Bis Sie die Lücke gemessen haben, hat kein Schwellenwert Ihr Vertrauen verdient.

Die Regel im Code

Hier ist es als Lernspielzeug. Ein paar Zeilen, um die Struktur sichtbar zu machen, nicht etwas, das ich gebaut oder versendet habe.

def should_act_autonomously(stated_confidence: float,
                            cost_of_error: float,
                            cost_of_escalation: float,
                            calibrate) -> bool:
    """
    Educating toy: act alone or escalate, by anticipated value.

    `calibrate` maps said confidence to a measured
    chance of being appropriate, constructed from logged
    choices and realised outcomes.
    """
    p_correct = calibrate(stated_confidence)

    expected_cost_of_acting = (1 - p_correct) * cost_of_error
    expected_cost_of_asking = cost_of_escalation

    return expected_cost_of_acting < expected_cost_of_asking

Die Funktion enthält nichts Besonderes. Was wirklich zählt, ist, wie Sie die drei Eingaben auswählen. Hier sollten Sie sich anstrengen, anstatt darüber zu streiten, ob die magische Zahl 0,85 oder 0,92 sein sollte.

Wo die Zahlen chaotisch werden

Zwei Faktoren machen die Eingaben komplizierter.

Die Eskalationskosten betragen nicht nur Minuten mal Gehalt. Eskalationen häufen sich in einer Warteschlange, und die Warteschlangen verstopfen sich. Schlimmer noch: Eine übermäßige Eskalation bringt die Rezensenten dazu, sich abzunicken. Schicken Sie jemandem professional Stunde vierzig routinemäßige Rückerstattungen, und innerhalb einer Woche hat er aufgehört, sie zu lesen. Ein Mensch, der alles gutheißt, ist keine Kontrolle. Es ist ein Ritual. Die geringfügige Eskalation kostet additionally mehr, als es aussieht, und die Kluft wird mit zunehmendem Volumen größer.

Und erinnern Sie sich an die Annahme, die wir vorhin vertreten haben: Der Mensch macht es richtig. Oft tun sie das nicht. Geben Sie dem Spezialisten eine Fehlerrate h und die Regel wird wirksam, wenn (1 − p) × Fehlerkosten kleiner sind als Eskalationskosten plus h × Fehlerkosten. Normalerweise ist h klein genug, um ignoriert zu werden. Bei wirklich mehrdeutigen Tickets ist dies nicht der Fall und die Barriere verschiebt sich wieder in Richtung des Agenten. Das überrascht die Leute.

Keines dieser Probleme ändert den Gesamtansatz; Sie wirken sich nur auf die Zahlen aus. Das ist der Vorteil der Verwendung einer numerischen Methode.

Tun Sie dies für Ihren eigenen Agenten

Das Verfahren ist kurz.

Gruppieren Sie zunächst die Entscheidungen des Agenten in Klassen, bei denen die Kosten eines Fehlers ungefähr gleich sind. Ordnen Sie beispielsweise Rückerstattungen einer Klasse und Sicherheitsvorfälle einer anderen zu. Wenn Sie die Kosten eines Fehlers für eine Klasse nicht abschätzen können, ist sie noch nicht bereit für Autonomie. Tatsächlich ist es ein wertvoller Teil des Prozesses, dies herauszufinden.

Dann bepreisen Sie jede Klasse. Sprechen Sie mit den Leuten, die das Chaos beseitigen, nicht nur mit den Leuten, die den Agenten entwickelt haben. Finanz- und Supportmitarbeiter kennen diese Zahlen besser als die Technik und sind in der Regel froh, dass endlich jemand gefragt hat.

Schätzen Sie außerdem die Kosten einer Eskalation ein, einschließlich der Auswirkungen von Staus und Billigungen.

Verwenden Sie in Ihrer Regel die korrigierte Wahrscheinlichkeit, nicht den Rohwert.

Letzter Schritt: Leiten Sie den Schwellenwert professional Klasse aus dem Kostenverhältnis ab und lassen Sie ihn sich ändern, wenn sich die Kosten ändern. Ein neues Betrugsmuster erhöht den Preis eines Sicherheitsfehlers, sodass auch die Schwelle steigt. Es ist keine Besprechung erforderlich, da es sich um eine Ableitung und nicht um eine Verordnung handelt.

Am Ende wird Ihr Agent mehrere Schwellenwerte haben, nicht nur einen. Es wird mehr Autonomie haben, wenn Fehler billig sind, und viel weniger, wenn Fehler kostspielig sind. Das Modell und der Vergleich bleiben gleich.

Und das ist die ehrliche Antwort auf die Frage, mit der jeder beginnt. „Wie sicher sollte mein Agent sein, bevor er alleine handelt?“ Kann nicht beantwortet werden, da es nicht ausreichend spezifiziert ist. „Was kostet hier ein falscher Anruf und was kostet eine Nachfrage?“ dürfen. Legen Sie den Schwellenwert als Preis fest. Der Prozentsatz klärt sich von selbst.

# Einführung

Stellen Sie sich Folgendes vor: einen Multi-Agent-Workflow, der Dateien liest, Patches schreibt, Exams ausführt und über vier Dienste iteriert und dabei an einem einzigen Nachmittag 400 API-Aufrufe durchführt. Die Benachrichtigung kommt. Sie haben das weiche Restrict erneut überschritten. Jeder Token kostet Geld, jede Eingabeaufforderung sendet Ihren proprietären Code an einen Server eines Drittanbieters und die Ratenbegrenzungen unterbrechen lang laufende Sitzungen – die einzige Lösung besteht darin, mehr zu bezahlen.

Gemma 4 26B MoE aktiviert nur 3,8 Milliarden seiner 26 Milliarden Parameter professional Vorwärtsdurchlauf. Es erreicht 77,1 % LiveCodeBench v6 und 86,4 % eingeschaltet τ2-Financial institution Verwendung von Agententools – der Benchmark, der speziell testet, was passiert, wenn ein Modell in einem mehrstufigen Workflow Instruments aufrufen, Schritte ausführen und Fehler behandeln muss. Die vorherige Era, Gemma 3 27B, erreichte bei demselben Benchmark 6,6 %. Das ist kein kleines Improve. Es ist der Unterschied zwischen einem Modell, das Instruments nicht zuverlässig aufrufen kann, und einem Modell, das eine Agentenschleife von Claude Code ausführen kann, ohne seine Funktionsaufrufparameter ständig zu verfälschen.

Dieser Artikel erstellt den vollständigen Stack: Ollama stellt Gemma 4 lokal bereit, die Modelldatei, die Kontextfensterfehler in Agentensitzungen verhindert settings.json das Claude Code mit dem lokalen Endpunkt verbindet, ein Überprüfungsskript, das bestätigt, dass alles funktioniert, bevor Sie es mit echtem Code verwenden, und eine ehrliche Übersicht darüber, was kaputt geht und wie man es behebt. Das Publikum sind Ingenieure, die bereits wissen, was große Sprachmodelle (LLMs) sind und was Agentenschleifen kosten. Kein Händchenhalten bei den Grundlagen.

# Warum Gemma 4?

Gemma 4 wurde am 2. April 2026 unter Apache 2.0 veröffentlicht und ist die bisher leistungsfähigste Open-Weight-Modellfamilie von Google DeepMind. Vier Varianten werden ausgeliefert: E2B (2B effektiv), E4B (4B effektiv), 26B MoE und 31B Dense. Das 26B MoE nutzt 128 kleine Experten und aktiviert nur 8 professional Token plus einen gemeinsamen Experten und liefert so eine Qualität von nahezu 31B bei deutlich geringeren Rechenkosten.

Frühere Gemma-Versionen nutzten eine benutzerdefinierte Google-Lizenz mit kommerziellen Nutzungsbeschränkungen, die so unklar waren, dass die Rechtsabteilungen von Unternehmen sie routinemäßig als Blocker markierten. Gemma 4 ist Apache 2.0, eine Premiere für die Gemma-Familie. Wenn Ihr Workforce dies in interne Instruments einbetten, Produkte darauf ausliefern oder es ohne rechtlichen Prüfaufwand in Produktionspipelines ausführen möchte, ist diese Änderung operativ von Bedeutung.

// Die Zahlen, die für Codierungsagenten wichtig sind

// Hardwareanforderungen

Bevor Sie sich für ein 18-GB-Modell entscheiden, sollten Sie wissen, womit Sie tatsächlich arbeiten. Die Gemma 4-Familie wurde entwickelt, um Edge-Geräte bis hin zu Workstations zu umfassen, und die vier Varianten spiegeln diese Bandbreite wider.

// Ollama, Gemma 4 und Claude Code installieren

Schritt 1: Ollama installieren

# macOS and Linux -- one-line set up
curl -fsSL https://ollama.com/set up.sh | sh

# Confirm model -- have to be 0.14.0+ for Anthropic Messages API help
# The Anthropic-compatible endpoint was added in January 2026
ollama model
# Anticipated: ollama model is 0.22.x or larger (as of Might 2026)

# Home windows: obtain the native installer from https://ollama.com
# WSL2 is really useful if you'd like GPU passthrough on Home windows

Nach der Set up startet Ollama als Hintergrunddienst auf Port 11434. Überprüfen Sie, ob es aktiv ist:

curl http://localhost:11434
# Anticipated response: Ollama is working

Schritt 2: Ziehen Sie Gemma 4

# The 26B MoE -- really useful for this setup (~18 GB obtain)
ollama pull gemma4:26b

# Whilst you wait, affirm the obtain is progressing
ollama ps
# Exhibits at the moment downloading or working fashions

# Optionally available: additionally pull the 31B for comparability on succesful {hardware}
ollama pull gemma4:31b

# Affirm the pull accomplished
ollama listing
# Ought to present gemma4:26b with dimension and modification date

Schritt 3: Claude Code installieren

# Conditions: Node.js 18 or later
node --version   # Affirm you might be on 18+

# Set up Claude Code CLI globally
npm set up -g @anthropic-ai/claude-code

# Confirm the set up
claude --version

Wenn Ollama läuft und Gemma 4 gezogen ist, besteht der natürliche nächste Instinkt darin, die Umgebungsvariablen zu exportieren und Claude Code sofort zu starten.

# Die Modelldatei

OllamaDas Standardkontextfenster von Gemma 4 sind 4K-Tokens. Das eigentliche Kontextfenster von Gemma 4 ist 128K–256K. Diese 4K-Standardeinstellung ist kein Vorschlag – sie wird von Ollama verwendet, sofern Sie sie nicht überschreiben. In einer Claude Code-Agentensitzung, die Quelldateien liest, den Konversationsverlauf speichert und die Ergebnisse von Toolaufrufen über mehrere Runden hinweg pflegt, sind 4K-Tokens innerhalb von Sekunden erschöpft.

Ohne die Kontextüberschreibung verliert Claude Code während der Bearbeitung den Überblick über den Dateiinhalt, vergisst frühere Anweisungen und erzeugt fragmentierte Änderungen. Konkret: Wenn ein Agent versucht, eine Serviceklasse mit 200 Zeilen umzugestalten, vergisst er völlig, dass die zweite Hälfte existiert. Der Agent gibt keinen Fehler aus. Es arbeitet lediglich stillschweigend an einer unvollständigen Ansicht der Datei und erzeugt eine teilweise korrekte Ausgabe, die im weiteren Verlauf unterbrochen wird.

Der Repair ist eine Modelldatei, die die richtige Kontextgröße und andere Inferenzparameter in eine benannte Modellvariante einfügt. Erstellen Sie diese Datei:

# ~/.ollama/Modelfiles/gemma4-claude
# Gemma 4 26B MoE variant tuned for Claude Code agentic periods.
# Bakes context window, temperature, and system immediate into the mannequin
# so each Claude Code session begins with the proper configuration.
#
# Construct with:
#   mkdir -p ~/.ollama/Modelfiles
#   ollama create gemma4-claude -f ~/.ollama/Modelfiles/gemma4-claude

FROM gemma4:26b

# Context window -- 65536 tokens (64K) is the tested-safe ground for actual
# codebases with out triggering swap on 16-18 GB VRAM programs.
# Enhance to 131072 (128K) when you have headroom on 24 GB+ programs.
# Don't go above 131072 until you have got profiled your reminiscence utilization
# underneath load -- Ollama pre-allocates the total KV cache upfront.
PARAMETER num_ctx 65536

# Temperature -- 0.2 is intentionally low for agentic coding.
# Greater temperature introduces variability in device name parameter
# formatting that causes Claude Code's device validator to reject calls.
# For inventive duties, you'll set this larger. For agentic loops: low.
PARAMETER temperature 0.2

# top_p -- nucleus sampling threshold. 0.9 retains era centered
# whereas avoiding the repetition loops that top_p=1.0 can produce on
# lengthy agentic periods.
PARAMETER top_p 0.9

# repeat_penalty -- penalizes the mannequin for repeating tokens.
# 1.15 helps forestall device name loops the place Gemma 4 retries the identical
# failed device name with almost equivalent parameters indefinitely.
PARAMETER repeat_penalty 1.15

# num_predict -- most tokens per response. 4096 is enough for
# most code patches. Enhance to 8192 in case you usually generate
# giant recordsdata in a single era.
PARAMETER num_predict 4096

# System immediate -- reinforces coding agent conduct and specific
# device use self-discipline. Gemma 4 advantages from being reminded to
# decide to device calls moderately than describing what it will do.
SYSTEM """You're a senior software program engineer working as a coding agent.

When working with code:
- Learn recordsdata earlier than modifying them. By no means assume file contents.
- Make one centered change at a time and confirm it earlier than continuing.
- When a device name fails, look at the error fastidiously earlier than retrying.
  Don't retry with equivalent parameters. Diagnose first.
- Want surgical edits over full file rewrites.
- Run checks after every significant change, not after a batch of adjustments.
- If you're unsure in regards to the codebase construction, learn extra recordsdata
  moderately than guessing.

Be exact and methodical. Keep away from explaining what you might be about to do
when you could possibly merely do it."""

Erstellen Sie die Variante:

# Create the Modelfiles listing if it doesn't exist
mkdir -p ~/.ollama/Modelfiles

# Save the Modelfile content material from above to this path, then construct:
ollama create gemma4-claude -f ~/.ollama/Modelfiles/gemma4-claude

# Confirm the variant was created
ollama listing
# Ought to present gemma4-claude alongside gemma4:26b

# Fast smoke take a look at -- confirm it hundreds and responds
ollama run gemma4-claude "What's the time complexity of binary search and why?"
# Count on a transparent, concise technical response inside just a few seconds

# Claude-Code mit dem lokalen Modell verbinden

Nachdem die Modellvariante erstellt wurde, verbindet die Konfigurationsschicht Claude Code mit Ollama. Zwei Umgebungsvariablen bilden dabei den Kern, aber drei zusätzliche Variablen verhindern die häufigsten Fehlermodi.

Ollamas Anthropic-kompatibler Endpunkt ist bei http://localhost:11434nicht http://localhost:11434/v1. Der /v1 path ist Ollamas OpenAI-kompatible Ebene. Claude Code verwendet das Anthropic Messages API-Protokoll, das dem Root-Endpunkt zugeordnet ist. Mit der /v1 Der Pfad führt zu Authentifizierungsfehlern oder unerwartetem Verhalten.

// Globale Einstellungen – ~/.claude/settings.json

Diese Konfiguration gilt für jede Claude Code-Sitzung in allen Projekten. Es ist die richtige Wahl, es sei denn, Sie wechseln professional Projekt häufig zwischen lokalen und Cloud-Modellen.

{
  "env": {
    "ANTHROPIC_BASE_URL": "http://localhost:11434",

    "ANTHROPIC_AUTH_TOKEN": "ollama",

    "ANTHROPIC_API_KEY": "",

    "ANTHROPIC_MODEL": "gemma4-claude",

    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gemma4-claude",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gemma4-claude",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "gemma4-claude",

    "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS": "1"
  }
}

Warum jede Variable wichtig ist:

• ANTHROPIC_BASE_URL leitet alle Claude Code API-Aufrufe von den Servern von Anthropic an Ihre lokale Ollama-Instanz um.
• ANTHROPIC_AUTH_TOKEN muss auf eine beliebige nicht leere Zeichenfolge gesetzt werden; Ollama ignoriert den Wert, aber Claude Code erfordert, dass der Header vorhanden ist.
• ANTHROPIC_API_KEY: „“ Der Schlüssel wird explizit geleert, sodass Claude Code nicht auf einen echten Anthropic-API-Schlüssel zurückgreifen kann, falls einer in Ihrer Shell-Umgebung festgelegt ist. Ohne dies eine Fehlkonfiguration ANTHROPIC_BASE_URL könnte stillschweigend auf die kostenpflichtige API umsteigen.
• ANTHROPIC_MODEL ist der primäre Modellname, den Claude Code in Anfragen sendet. Stellen Sie dies auf Ihre benutzerdefinierte Modelfile-Variante ein. gemma4-claude nicht gemma4:26b. Das Rohmodell-Tag trägt nicht die Kontextfensterüberschreibung.
• ANTHROPIC_DEFAULT_SONNET_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODELUnd ANTHROPIC_DEFAULT_OPUS_MODEL: Claude Code leitet verschiedene Aufgabentypen intern an verschiedene Modellebenen weiter. Durch die Festlegung aller drei auf dasselbe lokale Modell wird sichergestellt, dass jede Anfrage bei Ihrer Ollama-Instanz landet, unabhängig davon, welche Ebene Claude Code intern auswählt.
• CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: „1“ Entfernt die Anthropic-spezifischen Beta-Header, die Claude Code zu Anfragen hinzufügt. Lokale Inferenzserver erkennen diese Header nicht und lehnen Anfragen ab, die sie enthalten. Das Setzen dieser Variablen verhindert diesen Fehler, ohne die Kernfunktionen von Claude Code zu beeinträchtigen.

// Projektspezifische Konfiguration – .claude/settings.json

Für Projekte, bei denen Sie die lokale Inferenz von Ihrem globalen Setup isolieren möchten – non-public Repositorys, wise Codebasen oder Projekte mit spezifischen Modellanforderungen – verwenden Sie stattdessen eine Einstellungsdatei auf Projektebene:

# In your venture root
mkdir -p .claude

cat > .claude/settings.json << 'EOF'
{
  "env": {
    "ANTHROPIC_BASE_URL": "http://localhost:11434",
    "ANTHROPIC_AUTH_TOKEN": "ollama",
    "ANTHROPIC_API_KEY": "",
    "ANTHROPIC_MODEL": "gemma4-claude",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gemma4-claude",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gemma4-claude",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "gemma4-claude",
    "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS": "1"
  }
}
EOF

Claude Code liest die Projektebene .claude/settings.json Wenn es vorhanden ist, werden die globalen Einstellungen für dieses Projekt überschrieben. Hinzufügen .claude/settings.json zu deinem .gitignore wenn die Einstellungen etwas Umgebungsspezifisches enthalten, oder übernehmen Sie es, wenn das gesamte Workforce lokale Rückschlüsse auf dieses Projekt ausführen soll.

// Überprüfen des Setups

Bevor Sie Claude Code mit einer echten Codebasis ausführen, überprüfen Sie drei Dinge: Ollama wird ordnungsgemäß bereitgestellt, das Modell reagiert auf API-Aufrufe im Anthropic Messages-Format und der Device-Aufruf funktioniert speziell. Der dritte Punkt ist nicht verhandelbar: Durch Toolaufrufe liest Claude Code Dateien, schreibt Patches und führt Befehle aus. Ein Modell, das Toolaufrufe nicht korrekt formatieren kann, führt zu einer Schleife und schlägt bei grundlegenden Agentenaufgaben fehl.

Voraussetzungen:

pip set up httpx   # Async HTTP shopper for the verification script

Das vollständige Verifizierungsskript:

#!/usr/bin/env python3
"""
verify_local_setup.py

Verifies the total Claude Code + Ollama + Gemma 4 stack earlier than use.
Runs three checks in sequence:
  1. Ollama well being and mannequin availability
  2. Primary Anthropic Messages API name
  3. Device calling round-trip

Conditions:
  pip set up httpx

The best way to run:
  python verify_local_setup.py

Anticipated output on a working setup:
  (PASS) Ollama is working on localhost:11434
  (PASS) Mannequin 'gemma4-claude' is on the market
  (PASS) Anthropic Messages API name profitable
  (PASS) Device calling: mannequin produced a sound tool_use block
  All checks handed -- Claude Code + Ollama + Gemma 4 is prepared.
"""

import httpx
import json
import sys

# ── Configuration ─────────────────────────────────────────────────────────────
OLLAMA_BASE_URL = "http://localhost:11434"
MODEL_NAME      = "gemma4-claude"   # Should match your Modelfile variant title
TIMEOUT         = 120.0             # Seconds -- era may be sluggish on first name


def check_ollama_health() -> bool:
    """
    Test 1: Confirm Ollama is working and responding.
    Hits the foundation endpoint which returns 'Ollama is working' when wholesome.
    """
    print("nCheck 1: Ollama well being")
    attempt:
        response = httpx.get(OLLAMA_BASE_URL, timeout=5.0)
        if "Ollama is working" in response.textual content:
            print(f"  (PASS) Ollama is working on {OLLAMA_BASE_URL}")
            return True
        else:
            print(f"  (FAIL) Sudden response: {response.textual content(:100)}")
            return False
    besides httpx.ConnectError:
        print(f"  (FAIL) Can not hook up with {OLLAMA_BASE_URL}")
        print("         Is Ollama working? Strive: ollama serve")
        return False


def check_model_available() -> bool:
    """
    Test 2: Confirm the particular mannequin variant is on the market in Ollama.
    Makes use of the /api/tags endpoint which lists all pulled fashions.
    """
    print("nCheck 2: Mannequin availability")
    attempt:
        response = httpx.get(f"{OLLAMA_BASE_URL}/api/tags", timeout=5.0)
        information     = response.json()
        fashions   = (m("title") for m in information.get("fashions", ()))

        # Normalize: Ollama could add ":newest" if not specified
        normalized = (m.cut up(":")(0) for m in fashions)

        if MODEL_NAME in fashions or MODEL_NAME in normalized:
            print(f"  (PASS) Mannequin '{MODEL_NAME}' is on the market")
            return True
        else:
            print(f"  (FAIL) Mannequin '{MODEL_NAME}' not discovered")
            print(f"         Obtainable fashions: {', '.be a part of(fashions) or 'none'}")
            print(f"         Run: ollama create {MODEL_NAME} -f ~/.ollama/Modelfiles/gemma4-claude")
            return False
    besides Exception as e:
        print(f"  (FAIL) Error checking mannequin listing: {e}")
        return False


def check_messages_api() -> bool:
    """
    Test 3: Ship a fundamental Anthropic Messages API name to the native endpoint.
    Verifies the request format, mannequin routing, and fundamental era work.
    Makes use of the identical /v1/messages path and request schema that Claude Code makes use of.
    Observe: Claude Code makes use of http://localhost:11434 (root), not /v1.
    The Anthropic-compatible API is at /api/chat or the foundation -- Ollama routes it.
    """
    print("nCheck 3: Anthropic Messages API name")

    payload = {
        "mannequin": MODEL_NAME,
        "max_tokens": 100,
        "messages": (
            {
                "function": "person",
                "content material": "Reply with precisely: VERIFICATION_OK"
            }
        )
    }

    headers = {
        "Content material-Sort":      "utility/json",
        "x-api-key":         "ollama",            # Required by the API spec; worth ignored regionally
        "anthropic-version": "2023-06-01"         # Required model header
    }

    attempt:
        response = httpx.publish(
            f"{OLLAMA_BASE_URL}/v1/messages",
            json=payload,
            headers=headers,
            timeout=TIMEOUT
        )

        if response.status_code != 200:
            print(f"  (FAIL) HTTP {response.status_code}: {response.textual content(:200)}")
            return False

        information = response.json()

        # Anthropic Messages API response construction:
        # { "content material": ({"kind": "textual content", "textual content": "..."}), "stop_reason": "..." }
        content_blocks = information.get("content material", ())
        text_blocks    = (b for b in content_blocks if b.get("kind") == "textual content")

        if not text_blocks:
            print(f"  (FAIL) No textual content content material in response: {json.dumps(information, indent=2)}")
            return False

        response_text = text_blocks(0).get("textual content", "")
        print(f"  (PASS) Anthropic Messages API name profitable")
        print(f"         Mannequin response: {response_text(:80)}")
        return True

    besides Exception as e:
        print(f"  (FAIL) Request failed: {e}")
        return False


def check_tool_calling() -> bool:
    """
    Test 4: Confirm device calling works end-to-end.
    That is crucial test for Claude Code agentic use.
    Claude Code depends on the mannequin appropriately producing tool_use blocks
    for each file operation, shell command, and code execution.

    Sends a easy device definition and a immediate that ought to set off it.
    Verifies the mannequin returns a tool_use block (not simply textual content describing the decision).
    """
    print("nCheck 4: Device calling verification")

    # A minimal device definition utilizing the Anthropic perform calling schema
    instruments = (
        {
            "title": "read_file",
            "description": "Learn the contents of a file on the given path.",
            "input_schema": {
                "kind": "object",
                "properties": {
                    "path": {
                        "kind": "string",
                        "description": "Absolutely the or relative file path to learn"
                    }
                },
                "required": ("path")
            }
        }
    )

    payload = {
        "mannequin": MODEL_NAME,
        "max_tokens": 256,
        "instruments": instruments,
        # Drive the mannequin to name a device moderately than reply in textual content.
        # tool_choice: {"kind": "any"} requires any device use.
        # Take away this if testing whether or not the mannequin self-selects instruments.
        "tool_choice": {"kind": "any"},
        "messages": (
            {
                "function": "person",
                "content material": "Learn the file at /tmp/take a look at.py and present me its contents."
            }
        )
    }

    headers = {
        "Content material-Sort":      "utility/json",
        "x-api-key":         "ollama",
        "anthropic-version": "2023-06-01"
    }

    attempt:
        response = httpx.publish(
            f"{OLLAMA_BASE_URL}/v1/messages",
            json=payload,
            headers=headers,
            timeout=TIMEOUT
        )

        if response.status_code != 200:
            print(f"  (FAIL) HTTP {response.status_code}: {response.textual content(:200)}")
            return False

        information           = response.json()
        content_blocks = information.get("content material", ())
        tool_blocks    = (b for b in content_blocks if b.get("kind") == "tool_use")

        if not tool_blocks:
            print("  (FAIL) Mannequin didn't produce a tool_use block")
            print("         This implies device calling just isn't working appropriately.")
            print("         Agentic Claude Code periods will fail on file operations.")
            print(f"         Full response: {json.dumps(information, indent=2)}")
            return False

        tool_call  = tool_blocks(0)
        tool_name  = tool_call.get("title", "")
        tool_input = tool_call.get("enter", {})

        print(f"  (PASS) Device calling: mannequin produced a sound tool_use block")
        print(f"         Device known as: {tool_name}")
        print(f"         Parameters:  {json.dumps(tool_input)}")

        # Sanity test: did it name the proper device with the proper parameter?
        if tool_name == "read_file" and "path" in tool_input:
            print(f"         Device title and parameter are right.")
        else:
            print(f"         WARNING: Sudden device title or lacking 'path' parameter.")
            print(f"         The mannequin known as a device however not the anticipated one.")

        return True

    besides Exception as e:
        print(f"  (FAIL) Request failed: {e}")
        return False


def predominant():
    print("=" * 60)
    print("Claude Code + Ollama + Gemma 4 Setup Verification")
    print("=" * 60)

    checks = (
        check_ollama_health,
        check_model_available,
        check_messages_api,
        check_tool_calling,
    )

    outcomes = (test() for test in checks)

    print("n" + "=" * 60)
    handed = sum(outcomes)
    complete  = len(outcomes)

    if all(outcomes):
        print(f"All {complete} checks handed.")
        print("Claude Code + Ollama + Gemma 4 is prepared.")
        print(f"nLaunch with: claude")
        sys.exit(0)
    else:
        failed_checks = (i + 1 for i, r in enumerate(outcomes) if not r)
        print(f"{handed}/{complete} checks handed. Failed: {failed_checks}")
        print("Resolve the failures above earlier than utilizing Claude Code regionally.")
        sys.exit(1)


if __name__ == "__main__":
    predominant()

So führen Sie aus:

pip set up httpx
python verify_local_setup.py

# Komplettlösung für Agentenaufgaben

Nach bestandener Verifizierung sieht eine echte Agentensitzung wie folgt aus. Die Aufgabe: Nehmen Sie ein vorhandenes Python-Modul ohne Exams, analysieren Sie es, schreiben Sie eine Testsuite, führen Sie die Exams aus und beheben Sie etwaige Fehler.

# Navigate to a venture listing
cd ~/tasks/my-service

# Affirm Claude Code sees the native configuration
claude --version
# Confirm it doesn't immediate for an Anthropic API key -- if it does,
# the settings.json just isn't being learn appropriately

# Begin an agentic session
claude

# Inside Claude Code, give the agent a concrete activity:
# > Analyze the UserService class in src/user_service.py.
# > Write a pytest take a look at suite protecting all public strategies.
# > Run the checks and repair any failures.
# > The objective is a clear pytest run with no skips.

So sieht die Aufrufverfolgung des Claude Code-Instruments während dieser Sitzung aus:

→ read_file("src/user_service.py")
  Studying 247 strains...

→ list_files("src/")
  Discovered: user_service.py, fashions.py, db.py, exceptions.py

→ read_file("src/fashions.py")
  Studying 89 strains...

→ write_file("checks/test_user_service.py", (take a look at content material))
  Written: 312 strains

→ bash("python -m pytest checks/test_user_service.py -v 2>&1")
  Working 14 checks...
  FAILED checks/test_user_service.py::test_update_email_invalid
    AssertionError: Anticipated ValidationError, obtained None

→ read_file("src/user_service.py")  (focused re-read of update_email methodology)
  ...

→ write_file("checks/test_user_service.py", (corrected take a look at))
  Patched test_update_email_invalid assertion

→ bash("python -m pytest checks/test_user_service.py -v 2>&1")
  14 handed in 1.23s

Gemma 4 bewältigt dieses Muster zuverlässig – es liest Dateien vor der Bearbeitung, führt Exams nach Änderungen durch und diagnostiziert Fehler anhand der Fehlerausgabe, anstatt es blind erneut zu versuchen. Beim Verhalten bei komplexen Architekturentscheidungen über viele Dateien hinweg haben Cloud-Modelle immer noch die Nase vorn. Für die oben genannte Aufgabe (Analyse, Testgenerierung und gezielte Korrekturen) ist das lokale Setup vollständig geeignet.

Worauf Sie achten sollten: Wenn Sie feststellen, dass der Agent die Fehlermeldung „Ungültige Werkzeugparameter“ ausgibt und es dann wiederholt mit denselben Parametern versucht, ist die Temperatur zu hoch oder das Modell verwendet das nicht gemma4-claude Modelfile-Variante. Sowohl die Temperatur als auch die Kontextfensterüberschreibung sind in die Variante integriert. das Rohe gemma4:26b Tag trägt sie nicht.

// Was kaputt geht und wie man es repariert

1. Fehler bei der Formatierung der Werkzeugparameter
   • Symptom: Claude Code berichtet Ungültige Werkzeugparameter wiederholt. Der Agent entschuldigt sich, versucht es erneut mit identischen oder nahezu identischen Parametern und führt dann eine Schleife aus.
   • Ursache: Dies ist in der dokumentiert Ollama GitHub-Probleme. Das Modell erzeugt einen Device-Aufruf-JSON, der nicht mit dem Schema übereinstimmt, das Claude Code erwartet. Am häufigsten: falsche Feldnamen, fehlende Pflichtfelder oder verschachtelte Objekte, bei denen Skalare erwartet werden.
   • Repair: Bestätigen Sie, dass Sie ausgeführt werden gemma4-claude (die Modelfile-Variante) nicht gemma4:26b direkt. Der temperature: 0.2 und die Systemeingabeaufforderung in der Modelldatei reduzieren dies erheblich. Wenn das Downside weiterhin besteht, senken Sie die Temperatur in der Modelldatei auf 0,1 und erstellen Sie neu.
2. Kontextfenster, das auf die Festplatte wechselt
   • Symptom: Die Erzeugung verlangsamt sich nach mehreren Runden auf ein Kriechtempo. ollama ps zeigt, dass die GPU-Auslastung sinkt. Das Betriebssystem lagert den KV-Cache auf die Festplatte aus.
   • Repair:

     # Possibility 1: Scale back context window within the Modelfile
     # Edit ~/.ollama/Modelfiles/gemma4-claude
     # Change: PARAMETER num_ctx 65536
     # To:     PARAMETER num_ctx 32768
     # Then rebuild: ollama create gemma4-claude -f ~/.ollama/Modelfiles/gemma4-claude
     
     # Possibility 2: Allow KV cache quantization to scale back reminiscence footprint
     export OLLAMA_KV_CACHE_TYPE=q8_0
     # This quantizes the KV cache itself, decreasing reminiscence at a small high quality price
     # Restart Ollama after setting this: pkill ollama && ollama serve

3. Entladen des Modells zwischen Agentenrunden
   • Symptom: Merkliche Kaltstartverzögerung am Anfang jeder Claude-Code-Nachricht. Ollama entlädt das Modell nach einem Inaktivitäts-Timeout und lädt es für jede Anfrage neu.
   • Repair:

     # Hold the mannequin loaded indefinitely throughout your work session
     export OLLAMA_KEEP_ALIVE=-1
     
     # Or set it in your shell profile for everlasting impact
     echo 'export OLLAMA_KEEP_ALIVE=-1' >> ~/.zshrc
     
     # Alternatively, use the Ollama API to pin the mannequin
     curl http://localhost:11434/api/generate 
       -d '{"mannequin": "gemma4-claude", "keep_alive": -1}'
     # This pins the mannequin till you explicitly unload it or restart Ollama

4. Fehler bei der Ablehnung von Beta-Headern
   • Symptom: Claude Code produziert Unerwartete Werte für den anthropic-beta-Header Fehler beim Begin oder in der Mitte der Sitzung.
   • Repair: Bestätigen CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1" ist in deinem settings.json. Wenn Sie es stattdessen über den Shell-Export festlegen settings.jsonstellen Sie sicher, dass es in derselben Shell-Sitzung exportiert wird, in der claude läuft:

     echo $CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS
     # Should print: 1

# Zusammenfassung

Der in diesem Artikel beschriebene Stack ist kein Proof of Idea. Es handelt sich um eine funktionierende Produktionskonfiguration, die Ingenieure täglich ausführen, seit Ollama im Januar 2026 die Anthropic Messages API-Unterstützung hinzugefügt hat. Die Modelfile ist nicht non-compulsory; Es ist der Unterschied zwischen einem Device, das funktioniert, und einem Device, das stillschweigend unvollständige Ausgaben für Aufgaben mit mehreren Dateien erzeugt. Das Verifizierungsskript erkennt Konfigurationsprobleme, bevor sie während der Sitzung als verwirrende Agentenfehler auftauchen.

Das in diesem Artikel erstellte Setup ist ein privater Codierungsagent, der keine Kosten professional Token verursacht und die meisten täglichen Entwicklungsaufgaben – Codeanalyse, Testgenerierung, gezieltes Refactoring und Debugging – mit Generierungsgeschwindigkeiten erledigt, die auf moderner {Hardware} verwendbar sind.

Dieses Setup ist kein Ersatz für Cloud-Inferenzen auf komplexe Architekturüberlegungen in großen Codebasen oder SWE-Bench-Klassenaufgaben, die ein tiefes Repository-Verständnis im großen Maßstab erfordern.

Shittu Olumid ist ein Software program-Ingenieur und technischer Autor, der sich leidenschaftlich dafür einsetzt, modernste Technologien zu nutzen, um fesselnde Erzählungen zu erschaffen, mit einem scharfen Blick fürs Element und einem Gespür für die Vereinfachung komplexer Konzepte. Sie können Shittu auch auf finden Twitter.

Analyse der Medaillenverteilung bei den Olympischen Spielen und der Indikatoren für den nationalen Wohlstand über 30 Jahre

Vor einer Ewigkeit battle ich selbst so etwas wie eine Sportlerin – als kleines Mädchen habe ich ein bisschen Rhythmische Sportgymnastik gemacht. Ich erinnere mich, wie ich während der Olympischen Spiele 2004 in Athen stundenlang voller Ehrfurcht vor dem Fernseher saß und jede einzelne Darbietung der Rhythmischen Sportgymnastik verfolgte, bei der die beiden russischen Athleten sowohl Gold- als auch Silbermedaillen gewannen.

Bis heute schaue ich mir gerne alle Arten von Turnen an – ich habe jede Sekunde von Simone Biles‘ Auftritten genossen, die bei den Olympischen Spielen 2024 in Paris eine Menge Medaillen gewann. Was mir damals nicht auffiel, heute aber schon, ist, wie häufig es vorkommt, dass reiche und mächtige Länder bei solchen Sportveranstaltungen eine Menge Medaillen gewinnen. Es ist wirklich überraschend, wenn ein Athlet aus einem nicht so wohlhabenden Land es auf das Medaillenpodest schafft. Denken Sie zum Beispiel an Algeriens Imane Khelif im Boxen oder Pakistans Arshad Nadeem im Speerwerfen; beide gewannen in ihren Sportarten in einer eher unerwarteten Wendung der Ereignisse Goldmedaillen.

Ist das alles, was man braucht, um eine olympische Medaille zu gewinnen – in einem reichen und mächtigen Land geboren zu sein? Ganz sicher nicht – es erfordert sicherlich viel Anstrengung, Hingabe, Schmerz, Opfer und …