# Einführung

Qwythos-9B-Claude-Mythos-5-1M ist ein 9B-Argumentations- und Codierungsmodell, das auf Qwen3.5 basiert und für lokale Codierungsworkflows, Agentenentwicklung und Aufgaben mit langem Kontext entwickelt wurde. Das Interessante daran ist, dass es klein genug ist, um auf Client-{Hardware} ausgeführt zu werden, und dennoch leistungsfähig genug ist, um bei praktischen Codierungsaufgaben zu helfen.

In dieser Anleitung zeige ich Ihnen, wie Sie das Mythos-erweiterte Qwythos-Modell lokal ausführen können lama.cppdann verbinden Sie es mit Pi Sie können es additionally als lokalen Codierungsagenten verwenden. Ich verwende eine RTX 4070 Ti Tremendous mit 16 GB VRAM, wodurch ich die Q6_K MTP-Quantisierung bequem ausführen kann. Wenn Sie über eine 8-GB-GPU verfügen, empfehle ich, mit der Q4_K_M-Variante zu beginnen, da diese ein besseres Gleichgewicht zwischen Qualität, Geschwindigkeit und Speichernutzung bietet.

# llama.cpp installieren

Installieren Sie zunächst die offizielle Befehlszeilenschnittstelle (CLI) llama.cpp. Dadurch erhalten Sie Zugriff auf die llama Befehl, einschließlich llama servedie wir verwenden werden, um das Modell lokal auszuführen.

curl -LsSf https://llama.app/set up.sh | sh

Fügen Sie als Nächstes das Installationsverzeichnis zu Ihrem Shell-Pfad hinzu, damit Ihr Terminal es finden kann llama Befehl:

echo 'export PATH="$HOME/.native/bin:$PATH"' >> ~/.bashrc
supply ~/.bashrc

Um zu bestätigen, dass die Set up funktioniert hat, führen Sie Folgendes aus:

Wenn alles korrekt installiert ist, sollten Sie die verfügbaren Befehle und Optionen von llama.cpp sehen.

# Einrichten eines Hugging Face Cache-Verzeichnisses

Stellen Sie die ein Umarmendes Gesicht Speichern Sie den Cache an einem Ort mit ausreichend freiem Speicherplatz. Dies ist besonders nützlich auf Cloud-Maschinen, bei denen das Customary-Dwelling-Verzeichnis über begrenzten Speicherplatz verfügt.

export HF_HOME="/workspace/huggingface"
mkdir -p "$HF_HOME"

Um es über neue Terminalsitzungen hinweg beizubehalten, fügen Sie es Ihrer Shell-Konfiguration hinzu:

echo 'export HF_HOME="/workspace/huggingface"' >> ~/.bashrc
supply ~/.bashrc

# Starten des Qwythos MTP-Modells

Führen Sie das Q6_K MTP GGUF-Modell mit allen verfügbaren GPU-Schichten aus:

llama serve 
  -hf "empero-ai/Qwythos-9B-Claude-Mythos-5-1M-GGUF:MTP-Q6_K" 
  --alias "qwythos-9b-mtp" 
  --host 0.0.0.0 
  --port 8910 
  --n-gpu-layers all 
  --ctx-size 100000 
  --parallel 1 
  --batch-size 1024 
  --ubatch-size 512 
  --flash-attn on 
  --cache-type-k q8_0 
  --cache-type-v q8_0 
  --spec-type draft-mtp 
  --spec-draft-n-max 6 
  --threads 12 
  --threads-batch 24 
  --temp 0.6 
  --top-p 0.95 
  --top-k 20 
  --repeat-penalty 1.05 
  --jinja 
  --perf

Wenn Sie diesen Befehl zum ersten Mal ausführen, lädt llama.cpp die Modelldateien von Hugging Face herunter.

Danach wird das Modell in den GPU-Speicher geladen und ein lokaler Server gestartet.

Sobald das Modell ausgeführt wird, öffnen Sie die lokale Schnittstelle in Ihrem Browser:

Dadurch erhalten Sie auch einen OpenAI-kompatiblen lokalen API-Endpunkt unter:

Die Q6_K-Variante bietet eine bessere Ausgabequalität, verbraucht aber auch mehr Speicher. Wenn Sie auf VRAM- oder RAM-Probleme stoßen, reduzieren Sie diese --ctx-size Erste. Wenn das immer noch nicht reicht, probieren Sie stattdessen die Variante Q4_K_M.

Hier sind die wichtigsten Flags im Befehl:

Auf meiner RTX 4070 Ti Tremendous erreichte ich etwa 81,74 Token professional Sekunde. In meinem Take a look at warfare das Modell auch in der Lage, die Aufgabe zu durchdenken, die erforderlichen Instruments aufzurufen und den aktuellen Goldpreis zurückzugeben, wenn es im lokalen Agenten-Workflow verwendet wurde.

# Set up von Pi und der llama.cpp-Integration

Pi kann eine Verbindung zum lokalen llama.cpp-Server herstellen und das Modell als Codierungsagent verwenden. Der pi-llama Das Plugin wurde entwickelt, um Pi mit einem laufenden lokalen llama.cpp-Server zu verbinden, ohne dass ein externer API-Schlüssel erforderlich ist.

Pi installieren:

curl -fsSL https://pi.dev/set up.sh | sh

Installieren Sie das Plugin llama.cpp für Pi:

pi set up git:github.com/huggingface/pi-llama

Erstellen Sie ein kleines Testprojekt:

mkdir new-project
cd new-project

Standardmäßig sucht das Plugin nach llama.cpp auf Port 8080. In dieser Anleitung läuft unser lokaler Server auf Port 8910, daher müssen wir die richtige lokale API-Adresse festlegen, bevor wir Pi starten:

export LLAMA_BASE_URL="http://127.0.0.1:8910/v1"

Starten Sie nun Pi:

Geben Sie in Pi Folgendes ein:

Wählen Sie den lokalen Modellalias aus:

Das Modell sollte in Pi aufgelistet sein. Sobald Sie es ausgewählt haben, können Sie es als lokalen Codierungsagenten verwenden.

# Testen des Mythos-Enhanced Coding Mannequin mit Pi

Jetzt ist es an der Zeit, das lokale Modell an realen Codierungsaufgaben in Pi zu testen. Ich habe zwei einfache, aber praktische Aufgaben verwendet: ein Browserspiel und ein kleines Python-CLI-Software.

// Erstellen eines einfachen Browsergames

Beginnen Sie mit einer Eingabeaufforderung, die Pi auffordert, ein kleines Browserspiel namens „Beat the AI“ zu erstellen.

Erstellen Sie ein einfaches Browserspiel namens „Beat the AI“.

Der Spieler hat 30 Sekunden Zeit, um kurze Fragen zur Mustererkennung zu beantworten. Jede richtige Antwort erhöht die Punktzahl um eins. Zeigen Sie einen Countdown-Timer, eine Punkteanzeige, einen Fortschrittsbalken und einen Bildschirm mit den Endergebnissen an.

Anforderungen:
– Verwenden Sie nur HTML, CSS und Vanilla-JavaScript.
– Generieren Sie mindestens drei Arten von Fragen, z. B. Zahlenmuster, schnelle Mathematik und Wortlogik.
– Fügen Sie nach Spielende eine Neustart-Schaltfläche hinzu.
– Sorgen Sie dafür, dass sich die Benutzeroberfläche verspielt und elegant anfühlt.
– Halten Sie den gesamten Code leicht verständlich und vermeiden Sie unnötige Dateien.

Testen Sie das Spiel im Browser, bevor Sie es beenden.

In meinem Take a look at hat Pi das vollständige Spiel in einer einzigen HTML-Datei mit eingebettetem CSS und JavaScript erstellt, wodurch das Projekt einfach und leicht zu überprüfen bleibt.

Pi fasste dann zusammen, was es erstellt hat, einschließlich des 30-Sekunden-Countdowns, der Punkteverfolgung, des Fortschrittsbalkens, der Fragetypen und der Neustart-Schaltfläche.

Danach habe ich das Spiel im Browser geöffnet, um zu überprüfen, ob es richtig funktioniert.

Das Ergebnis warfare ein ausgefeiltes kleines Spiel mit:

• Ein Countdown-Timer
• Eine Punkteanzeige
• Ein Fortschrittsbalken
• Mehrere Fragetypen
• Ein Neustartablauf nach Spielende

Dies ist ein gutes Beispiel dafür, wie das Modell eine komplette Entrance-Finish-Aufgabe lokal bewältigen kann, ohne dass eine externe API erforderlich ist.

// Erstellen einer CSV-zu-Excel-Python-CLI

Bitten Sie Pi für den zweiten Take a look at, eine kleine Python-CLI zu erstellen, die eine CSV-Datei in eine Excel-Datei konvertiert .xlsx Datei.

Erstellen Sie eine einfache Python-CLI, die eine CSV-Datei in eine Excel-XLSX-Datei konvertiert, Eingabe- und Ausgabedateipfade als Argumente akzeptiert, Spaltenüberschriften beibehält, fehlende Dateien validiert und klare Erfolgs- oder Fehlermeldungen ausgibt. Bevor Sie fertig sind, erstellen Sie eine kleine Dummy-CSV-Datei mit Beispieldaten, testen Sie damit die CLI, überprüfen Sie, ob die Excel-Datei korrekt erstellt wurde, und fassen Sie dann das Testergebnis zusammen.

Pi hat ein Python-Skript mit dem Namen erstellt csv2excel.pygenerierte eine Beispiel-CSV-Datei, führte den Testbefehl aus und fasste dann die Ergebnisse zusammen.

python csv2excel.py sample_data.csv output.xlsx

In meinem Durchlauf zeigte die Zusammenfassung, dass das Skript:

• Akzeptierte Eingabe- und Ausgabedateipfade.
• Die Spaltenüberschriften wurden beibehalten.
• Die Beispieldaten wurden korrekt konvertiert.
• Fehlende Dateien wurden mit eindeutigen Fehlermeldungen behandelt.
• Fehlende Ausgabepfade wurden ordnungsgemäß behandelt.

Ich habe auch die generierte Excel-Datei geöffnet, um zu bestätigen, dass die Ausgabe korrekt warfare.

In der Beispielausgabe wurden die Zeilen und Header korrekt beibehalten, was bestätigte, dass die CLI wie erwartet funktionierte.

# Letzte Gedanken

Ich magazine dieses kleine lokale Codierungsmodell wirklich. Es ist schnell, genau genug für alltägliche Codierungsaufgaben und benötigt nicht viel VRAM, um nützlich zu sein. Sie können es mit Pi verwenden, Claude Code, OpenCodeoder ein beliebiges Codierungssetup, das lokale OpenAI-kompatible oder Anthropic-kompatible Endpunkte unterstützt.

Für einfache Entrance-Finish-Apps, Python-Skripte, CLI-Instruments und schnelle Prototypen funktioniert es überraschend intestine. Sie können nützliche Projekte lokal erstellen, ohne auf externe APIs angewiesen zu sein oder für jede Anfrage zu bezahlen.

Um noch bessere Ergebnisse zu erzielen, empfehle ich dringend, Fähigkeiten zur Websuche hinzuzufügen. Kontext7und andere nützliche Pi-Integrationen. Sie können sich hier auch meinen vollständigen Leitfaden zur Optimierung Ihres Pi-Coding-Agent-Setups ansehen: So richten Sie Kimi K2.7-Code mit Pi ein: Die ultimative KI-Codierungsumgebung.

Abid Ali Awan (@1abidaliawan) ist ein zertifizierter Datenwissenschaftler, der gerne Modelle für maschinelles Lernen erstellt. Derzeit konzentriert er sich auf die Erstellung von Inhalten und das Schreiben technischer Blogs zu maschinellem Lernen und Datenwissenschaftstechnologien. Abid verfügt über einen Grasp-Abschluss in Technologiemanagement und einen Bachelor-Abschluss in Telekommunikationstechnik. Seine Imaginative and prescient ist es, ein KI-Produkt mithilfe eines graphischen neuronalen Netzwerks für Schüler mit psychischen Erkrankungen zu entwickeln.

Laut der New York Instances befindet sich Meta Berichten zufolge in Gesprächen über die Vermietung von Rechenleistung an Anthropic im Wert von bis zu 10 Milliarden US-Greenback über einen Zeitraum von zwei Jahren. Diese Vereinbarung würde Meta einen neuen Geschäftsweg eröffnen und Anthropic gleichzeitig bei der Sicherung wesentlicher Computerressourcen unterstützen.

Der Vorschlag wurde ursprünglich im Juni von Anthropic gemacht. Die Zahlungen für den Deal würden während der zweijährigen Laufzeit in monatlichen Raten erfolgen, und jede Partei hätte die Möglichkeit, den Vertrag vorzeitig zu kündigen. Der Umfang des Offers ist deutlich kleiner als bei einer früheren Vereinbarung zwischen Anthropic und SpaceX, die sich über einen Zeitraum von drei Jahren auf etwa 45 Milliarden US-Greenback bei 1,25 Milliarden US-Greenback professional Monat perception.

Beide Unternehmen äußerten sich nicht zu den laufenden Verhandlungen, die sich noch in einem frühen Stadium befinden und möglicherweise scheitern könnten. Die Dringlichkeit solcher Vereinbarungen ergibt sich aus dem harten Wettbewerb zwischen führenden KI-Unternehmen, darunter Meta, Google und Microsoft, die sich trotz erheblicher Investitionen in Rechenzentren eine angemessene Rechenleistung sichern möchten.

Der erhebliche Ausbau von Rechenzentren hat bei Investoren Bedenken hinsichtlich der Rechtfertigung dieser Ausgaben hervorgerufen. Theo Jaffee von MTS erklärte, dass „Anthropic viel Rechenleistung benötigt und Meta über viel Rechenleistung verfügt“, was eine mögliche Übereinstimmung der betrieblichen Anforderungen zwischen den beiden Unternehmen widerspiegelt.

Ein Deal könnte auch die Bedenken der Aktionäre hinsichtlich der umfangreichen Infrastrukturausgaben von Meta zerstreuen. Mark Zuckerberg berichtete, dass Meta in diesem Jahr bis zu 145 Milliarden US-Greenback ausgeben will, mehr als das Doppelte der 72 Milliarden US-Greenback im Vorjahr. Trotz dieser aggressiven Ausgaben sind Zweifel an der Wirksamkeit der KI-Modelle von Meta aufgetaucht, was die Skepsis der Aktionäre weiter schürt.

Um seine Ressourcen zu optimieren, hat Meta darüber nachgedacht, seine überschüssigen Kapazitäten zu leasen. Zuckerberg deutete während eines Investorenaufrufs im Mai an, dass Unternehmen Interesse am Kauf von Rechenleistung bekundet hätten, was Meta zuvor abgelehnt hatte, in der Annahme, dass der interne Bedarf ausreichen würde. Eine Überbauung würde jedoch einen Strategiewechsel hin zur Vermietung ungenutzter Kapazitäten erfordern.

Die Knappheit an Rechenressourcen hat auch zu einer Zusammenarbeit zwischen Wettbewerbern geführt. Anthropic hat einen Wert von rund 1,2 Billionen US-Greenback und bereitet sich auf einen Börsengang vor. Das Unternehmen stellt einen wachsenden Bedarf an Rechenressourcen dar, insbesondere nach der Einführung seines Claude-Code-Modells.

Neben dem möglichen Deal mit Anthropic ist Meta aktiv an anderen Mietverträgen beteiligt, darunter einem 21-Milliarden-Greenback-Deal mit CoreWeave und einem 27-Milliarden-Greenback-Vertrag mit Nebius. Steigende Preise für Rechenressourcen haben Meta dazu veranlasst, als Reaktion auf die Marktnachfrage darüber nachzudenken, eigene Rechenzentren zu vermieten.

Hervorgehobener Bildnachweis

werde ich meine ersten Eindrücke vom neuesten OpenAI-Modell, GPT-5.6, geben. Das Modell wurde vor ein paar Tagen veröffentlicht und ich hatte seit der Veröffentlichung Gelegenheit, es ausgiebig zu testen und mit anderen Modellen wie GPT-5.5, Opus 4.8 und Fable 5 zu vergleichen.

Ich gebe mein Urteil über das Modell ab, teile meine Erfahrungen damit und erkläre, wie ich möglichst effektiv damit arbeiten kann. Ich glaube, es ist ein Modell mit einigen Vor- und Nachteilen im Vergleich zu den alternativen Anthropic-Modellen wie Opus 4.8 und Fable 5. Aber insgesamt ist es ein sehr gutes Modell, und ich empfehle auf jeden Fall, es auszuprobieren.

Warum GPT-5.6 verwenden?

Zunächst möchte ich erläutern, warum Sie sich für diesen Artikel interessieren sollten. In diesem Fall geht es darum, warum Sie sich für GPT-5.6 interessieren sollten und wie Sie es effektiv nutzen können. Der Grund, warum Sie sich für GPT-5.6 interessieren sollten, ist zunächst einmal, dass die vorherige Technology desselben Modells, GPT-5.5, ein großartiges Modell warfare und ich persönlich ausgiebig genutzt habe.

Ich glaube, dass GPT-5.5 in vielen Aufgaben im Grunde Opus 4.8 ebenbürtig warfare, und in einigen Aufgaben, wie zum Beispiel der Codeüberprüfung, warfare es meiner Meinung nach weit überlegen.

Daher sollten Sie sich natürlich um die nächste Technology des gleichen Modells, GPT-5.6, kümmern, da diese auf dem Papier besser sein sollte. Darüber hinaus weist GPT-5.6 einige Macken auf, die Sie unbedingt kennen sollten. Das Modell gibt es beispielsweise in drei verschiedenen Größen:

Dabei bezieht sich Sol auf die Sonne, Terra auf die Erde und Luna auf den Mond, was die Größe der Modelle darstellt. Sol ist das beste Modell und das Grenzmodell. Außerdem haben sie für jedes Modell unterschiedliche Argumentationsebenen eingeführt, die dazu führen können, dass das Modell länger oder kürzer nachdenkt, bevor es Antworten liefert. Der einfache Kompromiss besteht darin, dass, wenn Sie die Modellbegründung länger gestalten, zwar qualitativ hochwertigere Antworten vorliegen, die Bereitstellung der Antworten jedoch länger dauert.

Ich werde meine Techniken und Gedanken darüber teilen, wie ich die Modelle so effektiv wie möglich nutzen kann.

Meine Gedanken zu GPT-5.6

Lassen Sie mich zunächst meine allgemeinen Gedanken zu GPT-5.6 darlegen. Insgesamt würde ich sagen, dass es in praktisch jeder Hinsicht eine Verbesserung gegenüber GPT-5.5 darstellt. Es ist einfach in allem ein bisschen besser als GPT-5.5.

Ich verwende das Modell natürlich für Codeüberprüfungen, bei denen es immer noch viele Probleme entdeckt. Ich glaube, es ist etwas besser darin, Probleme im Code zu erkennen, sowohl im Hinblick auf die Präzision als auch auf den Rückruf, d.

Ich habe das Modell auch für tatsächliche Implementierungen ausprobiert und glaube, dass GPT-5.6 in der Lage ist, länger zu arbeiten, um Aufgaben zu erledigen, und grundsätzlich gründlicher in der Artwork und Weise ist, wie es seine Arbeit erledigt. Ich glaube immer noch, dass GPT-5.5 ziemlich intestine darin warfare, Aufgaben zu erledigen, aber ich denke, dass GPT-5.6 etwas besser ist.

Allerdings ist es erwähnenswert, dass ich nicht denke, dass dies eine sehr starke Verbesserung ist; Ich glaube, dass es eine schrittweise Verbesserung gegenüber dem vorherigen GPT-Modell ist.

Ein Nachteil, den ich anmerken möchte, ist, dass, wenn Sie GPT-5.6 mit „Further Excessive“ oder sogar „Extremely Considering“ verwenden, Ihre Nutzungsgrenzen im Grunde sofort aufgebraucht werden.

Nun ist es erwähnenswert, dass OpenAI tatsächlich die Nutzungsbeschränkung von fünf Stunden aufgehoben hat, zumindest für einen vorübergehenden Zeitraum, was hier definitiv sehr hilfreich ist. Sie haben additionally nur das wöchentliche Restrict; Allerdings bin ich der Meinung, dass die Verwendung des Modells mit „Further Excessive“ oder „Extremely Considering“ im Grunde genommen sofort zu Lasten geht, und wenn Sie ein Abonnement haben, ist es sehr schwierig, das Modell über einen längeren Zeitraum zu verwenden, und auf jeden Fall sehr schwierig, mehrere Modelle parallel zu verwenden.

Darüber hinaus denke ich, dass das Modell auch sehr, sehr langsam ist, wenn man es mit einem dieser hochgradig schlussfolgernden Modi verwendet. Langsamer als ich es erwarten würde, auf jeden Fall bei der Arbeit an einfacheren Aufgaben. Daher habe ich letztendlich ein besonders hohes Denkvermögen für die Planung und ein mittleres Denkvermögen für tatsächliche Implementierungen verwendet, worauf ich im nächsten Abschnitt näher eingehen werde. Aber ich denke, es ist erwähnenswert, dass ich die Argumentationsebenen abschwächen musste, um nicht sofort auf Ratengrenzen zu stoßen.

Das ist natürlich wichtig, denn wenn man sich die Benchmarks ansieht, handelt es sich in der Regel um eine der Tremendous-Argumentationsebenen. Wenn Sie diese nicht nutzen können, weil sie Ihre Nutzung sofort belastet, dann verschlechtert das natürlich das Modell im Vergleich zu den Benchmarks effektiv für Sie, wenn Sie es ausprobieren.

Ich möchte auch einen kurzen Abschnitt über meine Gedanken zu den verschiedenen Größen, die Sie wählen können, veröffentlichen. Ich verwende hauptsächlich Sol, das größte Modell, da ich glaube, dass es das beste Modell ist. Ich habe jedoch einige Benchmarks gelesen, die besagen, dass es in manchen Situationen besser ist, Terra mit einem höheren Argumentationsniveau zu verwenden als Sol mit einem niedrigeren Argumentationsniveau. Ich habe das selbst ein wenig getestet und konnte keine großen Unterschiede feststellen, sodass ich bei den zuvor erwähnten Argumentationsbemühungen bei Sol geblieben bin.

So wenden Sie GPT-5.6 effektiv an, um Probleme zu lösen

Anwendungsfälle für GPT-5.6

Jetzt gehe ich darauf ein, wie man GPT-5.6 effektiv zur Lösung von Problemen nutzt. Das Wichtigste, mit dem Sie sofort beginnen sollten, insbesondere wenn Sie Claude Code verwenden, ist, Ihre Codeüberprüfungen von GPT durchführen zu lassen.

Meiner Meinung nach braucht man größtenteils keine menschlichen Codeüberprüfungen mehr. Natürlich benötigen Sie es möglicherweise, wenn es sich um ein kritisches Teil der Infrastruktur handelt oder Sie wirklich möchten, dass ein Mensch es sich ansieht, aber im Großen und Ganzen bin ich der Meinung, dass Codex als Codeprüfer intestine genug ist, um zu vermeiden, dass Fehler in die Produktion übertragen werden.

Jetzt können Sie GPT-5.6 natürlich auch für tatsächliche Implementierungen verwenden. Meiner Meinung nach gelingt es mir jedoch besser, das folgende Setup für Implementierungen zu verwenden. Schritt eins ist, dass ich Claude Fable verwende, um die Implementierung zu planen, und Schritt zwei ist, dass ich umsteige und die Implementierung stattdessen mit Claude Opus 4.8 ausführe. Meiner Meinung nach erhalte ich dadurch bessere Ergebnisse als nur die Verwendung von GPT-5.6, selbst wenn ich für die Planung eine höhere Argumentationsebene und für Implementierungen dann eine niedrigere Argumentationsebene verwende.

Und ein weiterer Punkt, für den Sie GPT-5.6 verwenden könnten, ist die Computernutzung oder Browsernutzung. Meiner Meinung nach eignet sich GPT sehr intestine für die Laptop- und Browsernutzung und ist bei der Interaktion mit dem Browser recht schnell, insbesondere wenn ich ein mittleres Argumentationsniveau verwende. Meiner Meinung nach navigiert GPT-5.6 unglaublich intestine in meinem Browser, was natürlich wichtig ist, wenn man beispielsweise Code durchgängig überprüft oder Aktionen im Browser für Sie ausführt. Daher glaube ich, dass dies ein sehr guter Anwendungsfall ist.

Techniken zur effektiven Nutzung von GPT-5.6

Jetzt gehe ich zu einigen spezifischen Techniken über, die ich bei der Verwendung von GPT-5.6 umsetze und anwende. Das erste Thema, das ich behandeln möchte, sind die Argumentationsebenen. Wie ich bereits erwähnt habe, ist das Modell meines Erachtens sowohl zu langsam als auch die Nutzungslimits viel zu schnell aufgebraucht, wenn Sie sich für die extrahohen oder extrem rationalen Stufen entscheiden, was nicht wirklich funktioniert, wenn Sie ein Abonnement haben, selbst wenn Sie ein 200-Greenback-Abonnement haben.

Die Technik, die ich zu verwenden begann, besteht darin, dass ich besonders intestine nachdenke, wenn ich mit GPT-5.6 airplane. Wenn ich additionally eine Aufgabe beginne, beginne ich immer mit dem Planmodus, der eine besonders hohe Argumentationstiefe bietet. Wenn der Plan fertig ist, wechsle ich zu einem mittleren Argumentationsniveau, um den Code tatsächlich zu implementieren, da die Codeimplementierung oft einfacher ist als die Codeplanung. Dies liegt daran, dass Sie bei der Codeplanung das gesamte Repository untersuchen und überlegen müssen, wie etwas implementiert werden soll, während die eigentliche Implementierung lediglich die Umsetzung des Plans ist, der bereits für Sie erstellt wurde.

Eine weitere sehr wichtige Technik bei der Verwendung von GPT-5.6 besteht darin, ihm Zugriff auf alles zu gewähren. Eine Sache, die mir ziemlich unangenehm aufgefallen ist, warfare, dass ich zuvor hauptsächlich mit Claude Code gearbeitet habe und Claude über MCP Zugriff auf alles gegeben habe, was ich verwende, wie Gmail, Google Kalender, Slack, Playwright MCP usw. Und als ich dann anfing, GPT-5.6 zu verwenden, warfare die Leistung schlechter, weil ich nicht daran gedacht hatte, ihm Zugriff auf alle diese Instruments zu gewähren. Mein weiterer wichtiger Tipp hier ist additionally, GPT-5.6 tatsächlich Zugriff auf alle benötigten Instruments zu gewähren.

OpenAI verfügt im Grunde über dieselben Konnektoren wie Claude Code, und es gibt keinen Grund, warum Sie Codex keinen Zugriff gewähren sollten, wenn Sie Claude Code bereits Zugriff gewähren.

Und zum Schluss noch der letzte Tipp, den ich behandeln möchte: Denken Sie daran, dass OpenAI oft Resets ausgibt, was einer der großen Unterschiede zwischen Claude Code und Codex ist. Daher werden bei Claude Code manchmal die Nutzungslimits für alle zurückgesetzt, was natürlich großartig ist, wenn Sie einen Teil Ihrer Limits ausgegeben haben; Allerdings macht Codex das auch, aber sie bieten Ihnen in der Regel tatsächlich einen Banked-Reset an, bei dem es sich im Grunde um einen Reset handelt, den Sie jederzeit auslösen können und der Ihre Nutzungslimits zurücksetzt.

Dies kann großartig sein, wenn Sie für einen kürzeren Zeitraum eine hohe erwartete Nutzung haben oder wenn Sie gerade alle Ihre Token ausgegeben haben und noch mehr Token ausgeben müssen. Beachten Sie jedoch, dass durch das Zurücksetzen der Nutzungsbeschränkungen nicht nur Ihre Nutzung auf 0 % zurückgesetzt wird, sondern auch das Datum der nächsten Nutzungsrücksetzung zurückgesetzt wird. Ihr nächstes Fünf-Stunden-Restrict liegt additionally fünf Stunden später und Ihr nächstes Wochen-Restrict eine Woche später. Sie werden additionally auch zurückgesetzt, was den Nutzen der Financial institution-Resets verringert, obwohl sie natürlich immer noch sehr wertvoll sind.

In der Vergangenheit hat OpenAI hin und wieder Financial institution-Resets bereitgestellt. Wenn Sie additionally ein Abonnement haben, erhalten Sie diese im Laufe der Zeit.

Abschluss

In diesem Artikel habe ich meine Meinung zum neuesten OpenAI-Modell, GPT-5.6, und meine Gedanken dazu dargelegt. Ich habe besprochen, warum Sie das Modell verwenden sollten, und hervorgehoben, dass die vorherige Technology des OpenAI-Modells, GPT-5.5, bereits sehr intestine warfare und dass dies eine Verbesserung gegenüber dem Modell darstellt. Ich habe auch einige spezifische Techniken zur effektiven Nutzung des Modells vorgestellt, was sehr wichtig ist, da GPT-5.6 über einige unterschiedliche Nutzungseinstellungen verfügt. Es gibt sie beispielsweise in drei unterschiedlichen Modellgrößen und auch mit unterschiedlichen Argumentationsstufen, zwischen denen Sie wählen können. Ich glaube, Sie sollten auf jeden Fall GPT-5.6 für Codeüberprüfungen verwenden. Und der Unterschied zwischen GPT-5.6 und Opus 4.8 ist nicht so groß, wenn es um Code-Implementierungen, Computernutzung usw. geht. Mein aktuelles Codierungs-Setup bleibt additionally bestehen: Claude Fable für die Planung, Opus 4.8 für die Ausführung und GPT-5.6 für die Überprüfung meines Codes. Natürlich sollten Sie immer über die neuesten Modelle informiert sein, diese selbst ausprobieren, sehen, ob sie für Ihre Anwendungsfälle besser funktionieren, und so herausfinden, ob sie für Sie related sind.

Nehmen Sie Kontakt auf

Mein kostenloses E-E-book und Webinar:

Verzehnfachen Sie Ihr Engineering mit LLMs (kostenloser 3-tägiger E-Mail-Kurs)

Holen Sie sich mein kostenloses E-E-book „Imaginative and prescient Language Fashions“.

Mein Webinar zu Imaginative and prescient Language Fashions

Finden Sie mich in den sozialen Netzwerken:

Unterstapel

LinkedIn

X / Twitter

In diesem Tutorial erkunden wir das Prasseln SDK durch den Aufbau eines Sprachagenten-Workflows, der simuliert, wie sich ein KI-Telefonassistent bei echten Gesprächen verhält. Wir arbeiten mit einem Anwendungsfall für eine Restaurantbuchung, in dem wir dynamische Anrufervariablen definieren, aufrufbare Instruments registrieren, Ausgaberichtlinien anwenden, Sprache-zu-Textual content- und Textual content-zu-Sprache-Verhalten simulieren und einen vollständigen skriptgesteuerten Anrufablauf ausführen, ohne dass Anmeldeinformationen für die Stay-Telefonie erforderlich sind. Wir überprüfen auch die installierte Patter-API, sofern verfügbar, erstellen ein deterministisches Agentengehirn, verfolgen modellierte Latenz- und Kostenmetriken und validieren das System durch Auswertungen im Regressionsstil. Schließlich verstehen wir, wie das Patter SDK Agentenlogik, Software-Nutzung, Sicherheitsüberprüfungen, Anrufsimulation und reale Bereitstellungsmuster in eine einzige strukturierte Sprachagenten-Pipeline integriert.

from __future__ import annotations
import sys, subprocess, importlib, examine, time, json, re, random, textwrap, os
from dataclasses import dataclass, subject
from statistics import median
def _try_install(pkg: str) -> None:
   attempt:
       subprocess.run((sys.executable, "-m", "pip", "set up", "-q", pkg),
                      test=False, timeout=600)
   besides Exception:
       go
def _load_patter():
   """Return the actual getpatter module if importable, else None."""
   for title in ("patter", "getpatter"):
       attempt:
           return importlib.import_module(title)
       besides Exception:
           proceed
   return None
_PATTER = _load_patter()
if _PATTER is None:
   _try_install("getpatter")
   _PATTER = _load_patter()
def show_real_api():
   """Print the *precise* put in Patter API so the tutorial adapts to
   no matter model Colab pulled (getpatter is younger & strikes weekly)."""
   print("=" * 74)
   print("PATTER SDK — put in API")
   print("=" * 74)
   if _PATTER is None:
       print("getpatter not importable on this kernel (that is wonderful — then"
             "Colab demo beneath is self-contained). On a recent Colab it willn"
             "`pip set up getpatter` and this block prints the stay API.n")
       return
   print(f"module   : {_PATTER.__name__}")
   print(f"model  : {getattr(_PATTER, '__version__', 'unknown')}")
   exported = (n for n in dir(_PATTER) if not n.startswith('_'))
   print("exports  :", ", ".be part of(exported(:24)) + (" ..." if len(exported) > 24 else ""))
   Patter = getattr(_PATTER, "Patter", None)
   if Patter just isn't None:
       for meth in ("__init__", "agent", "serve", "name", "take a look at", "software"):
           fn = getattr(Patter, meth, None)
           if callable(fn):
               attempt:
                   print(f"Patter.{meth:<8}: {examine.signature(fn)}")
               besides (TypeError, ValueError):
                   print(f"Patter.{meth:<8}: <builtin/!signature>")
   print()
random.seed(7)
CALL_VARIABLES = {
   "customer_name": "Priya",
   "loyalty_tier":  "Gold",
   "restaurant":    "Acme Bistro",
}
USE_REAL_LLM = False
TOOLS: dict(str, dict) = {}
def software(description: str):
   def deco(fn):
       params = (p for p in examine.signature(fn).parameters)
       TOOLS(fn.__name__) = {"fn": fn, "description": description, "params": params}
       return fn
   return deco
import copy
_OPEN_TABLES_INIT = {
   ("as we speak", "night"): 6, ("as we speak", "late"): 2,
   ("tomorrow", "lunch"): 8, ("tomorrow", "night"): 4,
   ("friday", "night"): 0, ("friday", "late"): 3,
}
_RES_DB_INIT = {"AC8842": "Desk for two, tomorrow 7:30pm, beneath Singh — confirmed."}
_HOURS = {"weekday": "11:00–22:00", "weekend": "10:00–23:00"}
_OPEN_TABLES = copy.deepcopy(_OPEN_TABLES_INIT)
_RES_DB = copy.deepcopy(_RES_DB_INIT)
def _reset_backend():
   """Every simulated name begins from a clear backend (an actual name hits a
   recent DB connection). Retains the eval suite deterministic throughout runs."""
   _OPEN_TABLES.clear(); _OPEN_TABLES.replace(copy.deepcopy(_OPEN_TABLES_INIT))
   _RES_DB.clear();      _RES_DB.replace(copy.deepcopy(_RES_DB_INIT))
@software("Examine whether or not tables are free for a date/time slot and occasion dimension.")
def check_availability(date: str, slot: str, party_size: int) -> str:
   seats = _OPEN_TABLES.get((date, slot), 0)
   if seats >= party_size:
       return f"AVAILABLE: {seats} seats open for {date} {slot}."
   return f"FULL: solely {seats} seats for {date} {slot} (want {party_size})."
@software("E book a desk and return a affirmation code.")
def book_table(title: str, date: str, slot: str, party_size: int) -> str:
   seats = _OPEN_TABLES.get((date, slot), 0)
   if seats < party_size:
       return f"FAILED: not sufficient seats for {party_size} on {date} {slot}."
   _OPEN_TABLES((date, slot)) = seats - party_size
   code = "AC" + str(random.randint(1000, 9999))
   _RES_DB(code) = f"Desk for {party_size}, {date} {slot}, beneath {title}."
   return f"BOOKED: code {code} — occasion {party_size}, {date} {slot}, {title}."
@software("Return opening hours for a given day kind.")
def get_hours(day_type: str) -> str:
   return _HOURS.get(day_type, _HOURS("weekday"))
@software("Search for an present reservation by its affirmation code.")
def lookup_reservation(code: str) -> str:
   return _RES_DB.get(code.higher(), "NOT_FOUND: no reservation with that code.")
@software("Hand the decision to a human host (Patter auto-injects transfer_call).")
def transfer_to_human(purpose: str) -> str:
   return f"TRANSFER: routing to a number — purpose: {purpose}."

Wir richten die Tutorial-Umgebung ein, indem wir die erforderlichen Bibliotheken importieren, non-obligatory das Patter SDK installieren und die installierte API überprüfen, wenn sie verfügbar ist. Wir definieren die dynamischen Anrufervariablen, erstellen eine kleine Software-Registrierung und bereiten ein In-Reminiscence-Restaurant-Backend für Verfügbarkeit, Reservierungen, Öffnungszeiten und Transfers vor. Wir registrieren auch die Kerntools, die es unserem simulierten Telefonagenten ermöglichen, Tische zu überprüfen, Reservierungen zu buchen, Bestätigungscodes nachzuschlagen und Anrufer an einen Menschen weiterzuleiten.

Hinzufügen von Ausgabeleitplanken und simulierten Sprachebenen

class GuardrailBlock(Exception):
   def __init__(self, safe_reply: str):
       self.safe_reply = safe_reply
_PII_EMAIL = re.compile(r"b(w.+-)+@(w-)+.(w.-)+b")
_PII_PHONE = re.compile(r"b(?:+?d(s-)?){9,13}db")
_INTERNAL  = re.compile(r"bCUST-d{4,}b")
_BANNED    = re.compile(r"b(rattling|hell|crap)b", re.I)
_OFFTOPIC  = re.compile(r"b(diagnos|prescri|lawsuit|authorized recommendation|treatment)b", re.I)
def gr_redact_pii(textual content: str, ctx: dict) -> str:
   textual content = _PII_EMAIL.sub("(e-mail hidden)", textual content)
   textual content = _PII_PHONE.sub("(quantity hidden)", textual content)
   return textual content
def gr_hide_internal_ids(textual content: str, ctx: dict) -> str:
   return _INTERNAL.sub("your account", textual content)
def gr_profanity(textual content: str, ctx: dict) -> str:
   return _BANNED.sub("—", textual content)
def gr_scope(textual content: str, ctx: dict) -> str:
   if _OFFTOPIC.search(textual content):
       increase GuardrailBlock("I am simply the reserving line, so I can not assist with "
                            "that — however I can take a reservation in the event you like.")
   return textual content
def gr_concise(textual content: str, ctx: dict) -> str:
   elements = re.cut up(r"(?<=(.!?))s+", textual content.strip())
   return " ".be part of(elements(:2)) if len(elements) > 2 else textual content
GUARDRAILS = (gr_scope, gr_hide_internal_ids, gr_redact_pii, gr_profanity, gr_concise)
def apply_guardrails(textual content: str, ctx: dict) -> str:
   for g in GUARDRAILS:
       textual content = g(textual content, ctx)
   return textual content
_WHISPER_FILLERS = {"you", "thanks", ".", "uh", "um"}
def fake_stt(utterance: str) -> tuple(str, float):
   """Return (transcript, latency_ms). Drops Whisper-style fillers like Patter's pipeline does."""
   t0 = time.perf_counter()
   tokens = (w for w in utterance.cut up() if w.decrease().strip(".,") not in _WHISPER_FILLERS)
   transcript = " ".be part of(tokens) if tokens else utterance
   lat = 60 + len(utterance) * 1.5 + random.uniform(0, 25)
   _spin(t0)
   return transcript, lat
def fake_tts(textual content: str) -> float:
   """Return synthesis latency_ms (time-to-first-audio-ish)."""
   return 90 + len(textual content) * 0.8 + random.uniform(0, 30)
def _spin(_t0):
   go
SYSTEM_PROMPT = (
   "You're the pleasant telephone host for {restaurant}. Caller: {customer_name} "
   "({loyalty_tier} member). Assist them ebook, test hours, lookup a "
   "reservation, or attain a human. Hold replies to at least one or two quick sentences."
)
FIRST_MESSAGE = "Hello {customer_name}, thanks for calling {restaurant}! How can I assist?"
def _fill(t: str, v: dict) -> str:
   for okay, val in v.gadgets():
       t = t.exchange("{" + okay + "}", str(val))
   return t
def parse_party(s: str):
   m = re.search(r"(?:for|occasion of|desk for|of)s+(d+)", s) or re.search(r"b(d+)s*(?:folks|visitors|of us|pax)", s)
   if m: return int(m.group(1))
   for w, n in _NUM.gadgets():
       if re.search(rf"b{w}b(?:s+(?:folks|visitors|of us))?", s): return n
   return None
def parse_date(s: str):
   for d in ("as we speak", "tonight", "tomorrow", "friday"):
       if d in s: return "as we speak" if d == "tonight" else d
   return None
def parse_slot(s: str):
   if re.search(r"b(lunch|midday|noon)b", s): return "lunch"
   if re.search(r"b(late|11pm|11 pm|after 10)b", s): return "late"
   if re.search(r"b(dinner|night|tonight|7|8|9|pm)b", s): return "night"
   return None
def parse_name(s: str):
   m = re.search(r"(?:i'?m|that is|title is|beneath)s+((A-Z)(a-z)+)", s)
   return m.group(1) if m else None
def parse_code(s: str):
   m = re.search(r"b(ACd{3,4})b", s.higher())
   return m.group(1) if m else None
def maybe_real_llm(historical past, user_text, ctx):
   """Optionally available: defer freeform small-talk to an actual LLM if USE_REAL_LLM + a key.
   Returns a string or None. Stored tiny and absolutely non-obligatory."""
   if not USE_REAL_LLM:
       return None
   attempt:
       if os.environ.get("OPENAI_API_KEY"):
           from openai import OpenAI
           sys_p = _fill(SYSTEM_PROMPT, ctx("vars"))
           msgs = ({"position": "system", "content material": sys_p}) + historical past + 
                  ({"position": "consumer", "content material": user_text})
           r = OpenAI().chat.completions.create(mannequin="gpt-4o-mini", messages=msgs, max_tokens=60)
           return r.selections(0).message.content material
   besides Exception:
       return None
   return None

Wir erstellen die Ausgabeleitplankenschicht, die dafür sorgt, dass der Telefonassistent sicher, prägnant und für den Buchungsanwendungsfall geeignet ist. Wir redigieren vertrauliche Informationen, verbergen interne Kunden-IDs, bereinigen unerwünschte Sprache, blockieren themenfremde Anfragen und halten die Antworten für ein besseres Telefonerlebnis kurz. Anschließend simulieren wir das Sprach-zu-Textual content- und Textual content-zu-Sprache-Verhalten, definieren die Systemaufforderung und fügen einfache Parsing-Funktionen für Gruppengröße, Datum, Zeitfenster, Identify und Reservierungscode hinzu.

Aufbau des Agentengehirns und Anrufsimulators

def agent_brain(historical past: listing, user_text: str, ctx: dict):
   """Core logic. `ctx` carries vars + slot state throughout turns."""
   s = user_text.decrease()
   st = ctx("state")
   if re.search(r"b(human|agent|consultant|supervisor|individual)b", s):
       return ("__tool__", "transfer_to_human", {"purpose": "caller requested a human"})
   if st.get("booked") and re.search(r"b(no|nope|that'?s all|that'?s it|bye|thanks|thanks)b", s):
       return "Thanks for calling — see you quickly!"
   if re.search(r"b(climate|inventory|joke|treatment|lawsuit)b", s):
       return "I am simply the reserving line for tonight's tables — need me to seize you one?"
   code = parse_code(s)
   if code or "lookup" in s or "my reservation" in s:
       if code:
           return ("__tool__", "lookup_reservation", {"code": code})
       st("intent") = "lookup"
       return "Positive — what's your affirmation code? It appears to be like like AC adopted by 4 digits."
   if re.search(r"b(hours|open|shut|closing)b", s):
       day_type = "weekend" if re.search(r"b(sat|solar|weekend)b", s) else "weekday"
       return ("__tool__", "get_hours", {"day_type": day_type})
   if re.search(r"b(ebook|reserve|desk|reservation)b", s) or st.get("intent") == "ebook":
       st("intent") = "ebook"
   if st.get("intent") == "ebook":
       for key, val in (("party_size", parse_party(s)), ("date", parse_date(s)),
                        ("slot", parse_slot(s)), ("title", parse_name(user_text) or st.get("title"))):
           if val just isn't None:
               st(key) = val
       if st.get("party_size") is None:
           return "Completely happy to ebook you in — how many individuals?"
       if st.get("date") is None:
           return f"Nice, a desk for {st('party_size')}. Which day — as we speak, tomorrow, or Friday?"
       if st.get("slot") is None:
           return "And lunch, dinner, or late seating?"
       if not st.get("checked"):
           st("checked") = True
           return ("__tool__", "check_availability",
                   {"date": st("date"), "slot": st("slot"), "party_size": st("party_size")})
       if st.get("title") is None:
           return "What title ought to I put it beneath?"
       if not st.get("booked"):
           st("booked") = True
           return ("__tool__", "book_table",
                   {"title": st("title"), "date": st("date"),
                    "slot": st("slot"), "party_size": st("party_size")})
       return "You are all set — anything?"
   if re.search(r"b(no|nope|that is all|bye|thanks)b", s):
       return "Thanks for calling — see you quickly!"
   return maybe_real_llm(historical past, user_text, ctx) or 
       "I can ebook a desk, test hours, or lookup a reservation — which might you want?"
def fold_tool_result(tool_name: str, uncooked: str, ctx: dict) -> str:
   """Flip a uncooked software outcome right into a pure spoken reply (what the LLM does
   with a function-call outcome on an actual Patter name)."""
   if tool_name == "check_availability":
       if uncooked.startswith("AVAILABLE"):
           return "Excellent news — that slot's open. What title ought to I put it beneath?"
       ctx("state")("checked") = False
       ctx("state")("slot") = None
       return "That one's full, sorry. Would one other time work — lunch or late seating?"
   if tool_name == "book_table" and uncooked.startswith("BOOKED"):
       code = uncooked.cut up("code ")(1).cut up(" ")(0)
       return f"Booked! Your affirmation code is {code}. The rest?"
   if tool_name == "get_hours":
       return f"We're open {uncooked}. Need me to order a desk?"
   if tool_name == "lookup_reservation":
       return ("Right here it's: " + uncooked) if not uncooked.startswith("NOT_FOUND") 
           else "I could not discover that code — may you learn it as soon as extra?"
   if tool_name == "transfer_to_human":
       return "In fact — connecting you to a number now. One second!"
   return uncooked
@dataclass
class Flip:
   speaker: str
   textual content: str
   stt_ms: float = 0.0
   llm_ms: float = 0.0
   tool_ms: float = 0.0
   tts_ms: float = 0.0
   software: str | None = None
   @property
   def total_ms(self): return self.stt_ms + self.llm_ms + self.tool_ms + self.tts_ms
@dataclass
class CallResult:
   transcript: listing = subject(default_factory=listing)
   turns: listing = subject(default_factory=listing)
def run_call(caller_lines: listing(str), variables: dict, barge_in_at: int | None = None) -> CallResult:
   _reset_backend()
   ctx = {"vars": dict(variables), "state": {}}
   historical past, res = (), CallResult()
   def communicate(textual content: str, llm_ms: float, software=None, tool_ms=0.0, truncate=None):
       t0 = time.perf_counter()
       attempt:
           protected = apply_guardrails(textual content, ctx)
       besides GuardrailBlock as b:
           protected = b.safe_reply
       if truncate:
           protected = protected.cut up()(:truncate)
           protected = " ".be part of(protected) + " —"
       gr_ms = (time.perf_counter() - t0) * 1000
       tts = fake_tts(protected)
       res.transcript.append(("agent", protected))
       res.turns.append(Flip("agent", protected, llm_ms=llm_ms + gr_ms,
                             software=software, tool_ms=tool_ms, tts_ms=tts))
       historical past.append({"position": "assistant", "content material": protected})
   communicate(_fill(FIRST_MESSAGE, ctx("vars")), llm_ms=5.0)
   for i, raw_line in enumerate(caller_lines):
       transcript, stt_ms = fake_stt(raw_line)
       res.transcript.append(("caller", transcript))
       historical past.append({"position": "consumer", "content material": transcript})
       t0 = time.perf_counter()
       out = agent_brain(historical past, transcript, ctx)
       llm_ms = (time.perf_counter() - t0) * 1000 + random.uniform(40, 120)
       truncate = 4 if (barge_in_at just isn't None and that i == barge_in_at) else None
       if isinstance(out, tuple) and out and out(0) == "__tool__":
           _, title, kwargs = out
           t1 = time.perf_counter()
           uncooked = TOOLS(title)("fn")(**kwargs)
           tool_ms = (time.perf_counter() - t1) * 1000 + random.uniform(10, 40)
           reply = fold_tool_result(title, uncooked, ctx)
           communicate(reply, llm_ms=llm_ms, software=title, tool_ms=tool_ms, truncate=truncate)
           res.turns(-1).stt_ms = stt_ms
       else:
           communicate(out, llm_ms=llm_ms, truncate=truncate)
           res.turns(-1).stt_ms = stt_ms
   return res

Wir implementieren das Gehirn des Hauptagenten, das den Gesprächsfluss über Buchung, Reservierungssuche, Fragen zu Öffnungszeiten, Personenvermittlung und Ersatzantworten steuert. Wir verwenden die analysierten Anrufereingaben und den gespeicherten Gesprächsstatus, um zu entscheiden, wann wir Folgefragen stellen, Instruments anrufen oder eine Reservierung abschließen möchten. Wir erstellen außerdem einen Anrufsimulator mit strukturierten Flip-Objekten, um skriptbasierte Gespräche durchzuführen und Latenz-, Software- und Transkriptdaten zu sammeln.

Drucken von Transkripten, Latenz-Dashboards und Regressionsauswertungen

def print_transcript(title: str, res: CallResult):
   print("n" + "─" * 74)
   print(f"  {title}")
   print("─" * 74)
   for who, txt in res.transcript:
       tag = " agent " if who == "agent" else " caller"
       print(f"{tag}│ {txt}")
def print_dashboard(res: CallResult):
   totals = (t.total_ms for t in res.turns)
   stt = (t.stt_ms for t in res.turns if t.stt_ms)
   llm = (t.llm_ms for t in res.turns)
   tts = (t.tts_ms for t in res.turns)
   tool_turns = (t for t in res.turns if t.software)
   def p95(xs): return sorted(xs)(max(0, int(len(xs) * 0.95) - 1)) if xs else 0
   price = sum(0.0009 for _ in stt) + sum(0.0004 for _ in res.turns) + sum(0.00018 * len(t.textual content) for t in res.turns)
   print("n  ┌─ Patter dashboard (modeled) ────────────────────────────┐")
   print(f"  │ agent turns        : {len(res.turns):<6}                             │")
   print(f"  │ software calls         : {len(tool_turns):<6} ({', '.be part of(t.software for t in tool_turns) or '—'})")
   print(f"  │ latency  p50 whole : {median(totals):6.0f} ms                          │")
   print(f"  │ latency  p95 whole : {p95(totals):6.0f} ms                          │")
   print(f"  │ STT avg / TTS avg  : {(sum(stt)/len(stt) if stt else 0):5.0f} ms / {(sum(tts)/len(tts) if tts else 0):5.0f} ms              │")
   print(f"  │ est. spend (illus.): ${price:5.3f}                              │")
   print("  └──────────────────────────────────────────────────────────┘")
def run_evals() -> bool:
   print("n" + "=" * 74)
   print("EVAL HARNESS — regression checks")
   print("=" * 74)
   instances, handed = (), 0
   def full_transcript(res): return " || ".be part of(f"{w}:{t}" for w, t in res.transcript)
   r1 = run_call(("I would prefer to ebook a desk", "4 of us", "tomorrow",
                  "dinner", "beneath Priya"), CALL_VARIABLES)
   ok1 = bool(re.search(r"affirmation code is ACd{4}", full_transcript(r1)))
   instances.append(("books a desk & returns a code", ok1))
   leak = apply_guardrails("Your document CUST-99812 exhibits VIP standing.", {"vars": {}, "state": {}})
   ok2 = "CUST-99812" not in leak and "your account" in leak
   instances.append(("guardrail hides inner CUST- ids", ok2))
   r3 = run_call(("are you able to give me treatment recommendation?"), CALL_VARIABLES)
   ok3 = "reserving line" in full_transcript(r3).decrease()
   instances.append(("refuses out-of-scope (medical)", ok3))
   r4 = run_call(("get me a human please"), CALL_VARIABLES)
   ok4 = any(t.software == "transfer_to_human" for t in r4.turns)
   instances.append(("transfers to a human on request", ok4))
   r5 = run_call(("ebook a desk", "two", "friday", "night"), CALL_VARIABLES)
   ok5 = "full" in full_transcript(r5).decrease() and "affirmation code" not in full_transcript(r5).decrease()
   instances.append(("handles a full slot gracefully", ok5))
   lengthy = apply_guardrails("One. Two. Three. 4.", {"vars": {}, "state": {}})
   ok6 = lengthy.depend(".") <= 2
   instances.append(("concise guardrail caps sentence depend", ok6))
   for title, okay in instances:
       handed += okay
       print(f"  ({'PASS' if okay else 'FAIL'})  {title}")
   print(f"n  {handed}/{len(instances)} handed")
   return handed == len(instances)

Wir formatieren die simulierten Anrufergebnisse in ein lesbares Transkript und ein Dashboard im Patter-Stil, das Agentenwechsel, Software-Anrufe, Latenz und geschätzte Ausgaben zusammenfasst. Wir bauen außerdem einen deterministischen Bewertungsrahmen auf, der prüft, ob der Agent Buchungen abschließt, interne IDs schützt, medizinische Anfragen außerhalb des Umfangs ablehnt, an einen Menschen weiterleitet, volle Zeitfenster bearbeitet und die Antworten prägnant hält. Wir verwenden diese Prüfungen, um zu überprüfen, ob sich der Telefon-Agent-Workflow zuverlässig verhält, bevor wir mit der tatsächlichen Bereitstellung fortfahren.

Wechseln Sie zu echten Anrufen mit Twilio und OpenAI Realtime

REAL_DEPLOYMENT = textwrap.dedent('''
   # ---- real_agent.py  (run OUTSIDE Colab; wants a paid provider + keys) ----
   # export TWILIO_ACCOUNT_SID=AC... ; export TWILIO_AUTH_TOKEN=...
   # export TWILIO_PHONE_NUMBER=+1...  ; export OPENAI_API_KEY=sk-...
   import asyncio
   from getpatter import Patter, Twilio, OpenAIRealtime
   telephone = Patter(provider=Twilio(), phone_number="+15550001234")
   # register the exact same instruments you examined above
   @telephone.software
   async def book_table(title: str, date: str, slot: str, party_size: int) -> str:
       ...  # your actual reserving backend
   agent = telephone.agent(
       engine=OpenAIRealtime(),                 # or pipeline: stt=DeepgramSTT(), tts=ElevenLabsTTS()
       system_prompt="You're the host for Acme Bistro. Caller: {customer_name}.",
       first_message="Hello {customer_name}, thanks for calling Acme Bistro!",
       variables={"customer_name": "Priya"},    # dynamic per-caller
       instruments=(book_table),
       guardrails=("no_pii", "stay_in_scope"),  # output guardrails
   )
   async def important():
       # inbound: tunnel=True spawns a Cloudflare tunnel + factors your quantity at it
       await telephone.serve(agent, tunnel=True, dashboard=True, recording=True)
       # outbound as a substitute:
       # await telephone.name(to="+15558675309", agent=agent, machine_detection=True)
   asyncio.run(important())
   # Or skip code totally and take a look at from a shell:  patter dev real_agent.py
''').strip()
def important():
   show_real_api()
   demoA = run_call(
       caller_lines=(
           "Hello, I would prefer to ebook a desk",
           "there will be 4 of us",
           "tomorrow",
           "for dinner",
           "put it beneath Priya",
           "no that is all, thanks",
       ),
       variables=CALL_VARIABLES,
   )
   print_transcript("Demo A — reserving (instruments + dynamic variables)", demoA)
   print_dashboard(demoA)
   demoB = run_call(
       caller_lines=(
           "what are your weekend hours?",
           "truly can I communicate to a human",
       ),
       variables=CALL_VARIABLES,
       barge_in_at=1,
   )
   print_transcript("Demo B — hours, barge-in & human switch", demoB)
   print_dashboard(demoB)
   all_green = run_evals()
   print("n" + "=" * 74)
   print("GRADUATE TO REAL CALLS  (copy into an area file — not Colab)")
   print("=" * 74)
   print(REAL_DEPLOYMENT)
   print("n tutorial completed" + ("  •  evals inexperienced" if all_green else "  •  evals RED"))
if __name__ == "__main__":
   important()

Wir bereiten eine Bereitstellungsvorlage im Produktionsstil vor, die zeigt, wie dieselbe getestete Logik aus Colab in ein echtes Telefonagenten-Setup verschoben werden kann. Wir umfassen die Struktur für die Verwendung von Patter mit Twilio, OpenAI Realtime, registrierten Instruments, dynamischen Variablen, Leitplanken, eingehender Bereitstellung, Dashboard-Überwachung, Aufzeichnung und ausgehenden Anrufen. Anschließend führen wir das vollständige Tutorial durch, indem wir die installierte API zeigen, zwei Demo-Aufrufe ausführen, Dashboards drucken, Auswertungen ausführen und den endgültigen Code für die Bereitstellung bei echten Aufrufen anzeigen.

Abschluss

Abschließend haben wir einen vollständigen Telefonagenten-Workflow im Patter-Stil erstellt, der die Kernstruktur eines Produktions-Sprach-KI-Programs widerspiegelt. Wir haben Instruments zur Verfügbarkeitsprüfung, Tischreservierung, Reservierungssuche und Weiterleitung von Anrufern an Menschen erstellt und diese dann mit Leitplanken, skriptgesteuerten Gesprächen, simulierter Latenz, Dashboards und Bewertungsprüfungen kombiniert. Wir haben auch gesehen, wie dieselbe getestete Logik später von einer eigenständigen Colab-Simulation zu echten Telefonanrufen über Twilio, OpenAI Realtime, Tunneling und die Bereitstellungsschnittstelle von Patter übergehen kann. Außerdem haben wir am Ende ein umfassendes Verständnis davon erlangt, wie wir eine Sprachagentenanwendung prototypisieren, testen, überwachen und vorbereiten können, bevor wir sie mit der Stay-Telefoninfrastruktur verbinden.

Schauen Sie sich das an Vollständige Codes mit Pocket book hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 150k+ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Möchten Sie mit uns zusammenarbeiten, um Ihr GitHub-Repo ODER Ihre Hugging Face Web page ODER Produktveröffentlichung ODER Ihr Webinar usw. zu bewerben? Vernetzen Sie sich mit uns

Sana Hassan, Beratungspraktikantin bei Marktechpost und Twin-Diploma-Studentin am IIT Madras, ist leidenschaftlich daran interessiert, Technologie und KI zur Bewältigung realer Herausforderungen einzusetzen. Mit großem Interesse an der Lösung praktischer Probleme bringt er eine neue Perspektive in die Schnittstelle zwischen KI und realen Lösungen ein.

# Einführung

Wenn man normalerweise nach einem LLM fragt – Abkürzung für „Großes Sprachmodell„ — für ein ordentliches, strukturierte Ausgabe Wie zum Beispiel bei JSON-Objekten ist eine Mischung aus sorgfältiger, schneller Erstellung und einer „Prise“ Glück erforderlich. Andernfalls kann es schwierig sein, das Modell dazu zu bringen, die erwartete perfekt strukturierte Ausgabe zu erhalten. Zumindest struggle es so, bis ein Roman erschien Open-Supply-Bibliothek kam auf den Plan: Umrisse.

Diese Bibliothek soll typische Probleme verhindern, die bei LLMs in diesen spezifischen ausgabeorientierten Anwendungsfällen auftreten, wie z. B. Halluzinationen. Genauer gesagt führt es ein gewisses Maß an deterministischer Sicherheit in den Ausgabegenerierungsprozess ein.

Lassen Sie uns herausfinden, was outlines Dies ermöglicht uns dieser anschauliche Artikel, in dem wir einige praktische Beispiele in Python zeigen!

# Anwendungsfall 1: A number of-Alternative-Klassifizierung für die Stimmungsanalyse

Bevor Sie sich vollständig mit dem ersten Anwendungsfall befassen, fragen Sie sich vielleicht. Wie funktioniert outlines funktioniert und wie garantiert es die Korrektheit in strukturierten Modellausgaben? Auf der Inferenzebene maskiert es „syntaktisch illegale“ Token während der Generierung, anstatt zu versuchen, fehlerhaften Textual content nach der Generierung zu korrigieren. Dies macht es praktisch unmöglich, die Regeln zu brechen, die dem spezifischen gewünschten Ausgabeformat zugrunde liegen.

Sehen wir uns ein erstes Beispiel an, in dem wir eine Analysepipeline für Kundensupporttickets aufbauen, und wir wollen genau eine Possibility aus einer begrenzten, genehmigten Liste möglicher Optionen. Das ist so ziemlich ein Klassifizierungsproblem, und generate.selection() ist die Funktion, die uns dabei hilft, es nachzuahmen, indem sie das vorliegende Modell dazu zwingt, eines der vordefinierten Literale oder Klassen auszuwählen.

Aber zuerst installieren wir es neben dem transformers So laden Sie vorab trainierte LLMs:

pip set up outlines(transformers)

Der folgende Code verwendet outlines.from_transformers() um ein vorab trainiertes Modell zu laden, das von den automatischen Klassen von Hugging Face für ein Modell und den zugehörigen Tokenizer unterstützt wird. Aber das Tüpfelchen auf dem i ist: Beide sind in einem verpackt outlines Objekt, das später dabei hilft, dem Modell mitzuteilen, was genau es erhalten soll. In der Inferenzphase übergeben wir nicht nur die Benutzeraufforderung, eine Bewertung zu klassifizieren, sondern auch eine Literal Objekt, das die Ausgabebeschränkungen enthält, auf die das Modell beschränken soll:

import outlines
from transformers import AutoTokenizer, AutoModelForCausalLM
from typing import Literal

# 1. Loading the backend utilizing commonplace Transformer-based fashions
model_name = "microsoft/Phi-3-mini-4k-instruct"

# We use outlines to load the mannequin with its from_transformers() perform
mannequin = outlines.from_transformers(
    AutoModelForCausalLM.from_pretrained(model_name),
    AutoTokenizer.from_pretrained(model_name)
)

# 2. Calling the mannequin straight, passing our authorised strings as sort constraints
sentiment = mannequin(
    "Classify the sentiment of this buyer evaluate: 'I have been ready two weeks for my supply and it is nonetheless lacking.'",
    Literal("Optimistic", "Adverse", "Impartial")
)

print(sentiment)

Ausgabe:

Ein Wort der Warnung an dieser Stelle: Obwohl das von uns definierte Literal Teil des integrierten Typisierungsmoduls von Python ist und nicht outlinesübernimmt unsere sofort einsatzbereite Bibliothek hier immer noch die Modellsteuerung: Sowohl das Modell als auch der Tokenizer werden in ein Objekt eingebunden, das Normal-Python-Typen erzwingt, wodurch unter der Haube eine Finite-State-Maschine entsteht, die die Ausgabe nur auf die bereitgestellten Optionen beschränkt.

# Anwendungsfall 2: JSON-Objektgenerierung

In diesem Beispiel wird zunächst ein Pydantic-Objekt definiert, das die gewünschte Struktur für ein JSON-Objekt definiert, das eine fiktive Figur mit Namen, Beschreibung und Alter beschreibt. Es verwendet dann unsere zuvor verpackte outlines Modell, das das Zeichenobjekt übergibt, um sicherzustellen, dass die generierte Ausgabe strikt dieser Struktur für das angeforderte JSON-Objekt folgt:

from pydantic import BaseModel

# 1. Outline a Pydantic mannequin for the specified JSON construction
class Character(BaseModel):
    title: str
    description: str
    age: int

# 2. Utilizing the outlines-wrapped mannequin to generate a JSON output conforming to the Pydantic mannequin
json_output = mannequin(
    "Generate a JSON object describing a fictional character named 'Anya'.",
    Character,
    max_new_tokens=200
)

print(json_output)

Ausgabe:

{ "title": "Anya", "description": "Anya is a younger, adventurous girl with a ardour for exploring new locations and assembly new folks. She has lengthy, curly hair and shiny inexperienced eyes that sparkle with curiosity. Anya is at all times desperate to be taught and likes to share her data with others. She is kind-hearted and at all times prepared to lend a serving to hand to these in want. Anya's favourite hobbies embody mountaineering, studying, and taking part in the guitar. She is a free spirit who values freedom and independence above all else." ,"age": 25 }

# Anwendungsfall 3: Reine JSON-Generierung für REST-APIs

Dieses dritte Beispiel, ebenfalls JSON-bezogen, ähnelt dem vorherigen, steht jedoch in einem etwas anderen Kontext. Stellen Sie sich vor, Sie erstellen eine API, die eine genau definierte JSON-Nutzlast zum Aktualisieren einer Datenbank erfordert. Die Aufforderung an einen Normal-LLM, diese Ausgabe zu erhalten, führt häufig zu lästigen, nachgestellten Zeichen wie Kommas, die einen JSON-Parser wahrscheinlich zum Absturz bringen.

Mit Umrissen definieren wir unser JSON-Nutzlastschema noch einmal mit einem Pydantic-basierten benutzerdefinierten Klassenobjekt.

from pydantic import BaseModel
from typing import Literal
import json

class ServerHealth(BaseModel):
    service_name: str
    uptime_seconds: int
    standing: Literal("OK", "DEGRADED", "DOWN")

# 1. Outlines ought to produce a uncooked string assured to be legitimate JSON
raw_json_string = mannequin(
    "Report the present standing of the primary Auth database.",
    ServerHealth,
    max_new_tokens=50
)

print(sort(raw_json_string))  # It will simply print: 

# 2. Fairly-printing
parsed_json = json.hundreds(raw_json_string)
print(json.dumps(parsed_json, indent=2))

Ausgabe:

{
  "service_name": "auth_db_status",
  "uptime_seconds": 1623456789,
  "standing": "OK"
}

# Schlussbemerkungen

Da LLMs darauf trainiert sind, Chat-Liebhaber zu sein, die in der Lage sind, die Syntax zu brechen oder zu halluzinieren, um in ihren Gesprächen mit uns „wie Menschen zu klingen“, kann es ein wenig mühsam sein, sie dazu zu bringen, zuverlässige, strukturierte Ausgaben wie saubere JSON-Objekte zu erzeugen. Beschreibt eine neue Open-Supply-Bibliothek, die deterministische Sicherheit in den Ausgabegenerierungsprozess von LLMs einführt, um eine bessere und zuverlässigere Generierung strukturierter Ausgaben zu ermöglichen. Dieser Artikel zeigte drei einfache, aber nützliche Anwendungsfälle für Anfänger mit diesem interessanten Device.

Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Unternehmer treffen täglich Entscheidungen, die sich auf Rentabilität, Cashflow und langfristiges Wachstum auswirken. Diese Entscheidungen werden effektiver, wenn sie auf zeitnahen, genauen Informationen basieren und nicht auf isolierten Berichten oder veraltete Tabellenkalkulationen. Ein intestine gestaltetes Geschäfts-Dashboard führt wichtige finanzielle und betriebliche Kennzahlen an einem Ort zusammen und hilft Führungskräften, potenzielle Probleme zu erkennen, bevor sie zu größeren Problemen werden.

Identifizieren Sie die Kennzahlen, die am wichtigsten sind

Ein Dashboard sollte sich auf die Indikatoren konzentrieren, die den größten Einfluss auf die Geschäftsleistung haben. Cashflow, Bruttomarge, Überalterung der Forderungen, Betriebskosten und Nettogewinn bilden eine solide finanzielle Grundlage. Betriebskennzahlen wie Lagerumschlag, Aktivität der Vertriebspipeline, Kundenbindung und Projektrentabilität können den Finanzergebnissen einen wertvollen Kontext verleihen.

Die gemeinsame Betrachtung dieser Messungen ermöglicht Geschäftsinhaber um Muster zu erkennen, die bei der Durchsicht einzelner Berichte möglicherweise nicht sichtbar sind. Steigende Umsätze können beispielsweise positiv erscheinen, bis sinkende Margen oder langsamere Kundenzahlungen einen wachsenden finanziellen Druck erkennen lassen.

Verwandeln Sie Daten in bessere Entscheidungen

Das Sammeln von Daten ist nur der erste Schritt. Ein nützliches Dashboard präsentiert Informationen in einem Format, das Traits, Ausnahmen und Leistungsänderungen leicht erkennbar macht. Durch den Vergleich der aktuellen Leistung mit historischen Ergebnissen, Budgets oder Prognosen können Führungskräfte feststellen, ob sich das Unternehmen in die richtige Richtung bewegt.

Regelmäßige Dashboard-Überprüfungen fördern zudem die proaktive Entscheidungsfindung. Anstatt auf die Finanzberichte zum Monatsende zu warten, können Eigentümer steigende Ausgaben, langsamere Einnahmen oder sinkende Rentabilität früh genug erkennen, um sinnvolle Anpassungen vorzunehmen. Organisationen können die Finanzaufsicht auch durch die Einbeziehung regelmäßiger Überprüfungen stärken Unternehmensversicherungsdienstleistungenhilft bei der Validierung von Finanzberichtsprozessen und der Identifizierung von Möglichkeiten für betriebliche Verbesserungen.

Schaffen Sie Sichtbarkeit im gesamten Unternehmen

Die finanzielle Leistung wird nicht nur durch Buchhaltungsdaten beeinflusst. Vertrieb, Betrieb, Einkauf, Kundenservice und Bestandsverwaltung tragen alle zum Gesamtgeschäftsergebnis bei. Durch die Verknüpfung dieser Funktionen durch eine zentralisierte Berichterstattung entsteht ein vollständigeres Bild der Unternehmensleistung und verringert die Wahrscheinlichkeit, dass wichtige Informationen innerhalb einzelner Abteilungen isoliert bleiben.

Ein effektives Dashboard für Geschäftsinhaber sorgt für mehr Einblick in die täglichen Abläufe und unterstützt gleichzeitig schnellere und fundiertere Entscheidungen. Wenn Finanz- und Betriebsdaten zusammenarbeiten, sind Führungskräfte besser in der Lage, blinde Flecken zu erkennen, auf veränderte Bedingungen zu reagieren und das Unternehmen langfristig mit größerem Vertrauen zu führen. Weitere Informationen finden Sie in der Infografik unten.

werde ich besprechen, wie man viele verschiedene Agenten mithilfe von Claude Code oder anderen Codierungsagenten orchestrieren kann

Wenn Sie mit Codierungsagenten arbeiten, möchten Sie so viele Agenten wie möglich parallel ausführen. Das macht die Zusammenarbeit mit Agenten so effektiv. Die Tatsache, dass Sie parallel arbeiten können und somit insgesamt mehr Arbeit erledigen können.

Eine der Herausforderungen bei der gleichzeitigen Einrichtung vieler Agenten besteht jedoch darin, den Überblick über alle Agenten zu behalten und den Agenten zu antworten, wenn sie Fragen an Sie haben.

In diesem Artikel erörtere ich, wie Sie damit umgehen können und wie Sie sogar eine weitere Abstraktionsebene nach oben verschieben können, indem Sie direkt mit Agenten sprechen, die eine Reihe anderer Agenten koordinieren. Ich verwende diese Techniken täglich, um mehr als 100 Agenten parallel zu betreiben.

Warum viele Agenten orchestrieren?

Zunächst möchte ich erläutern, warum ich über das spezifische Thema spreche. In diesem Artikel werde ich diskutieren oder hervorheben, warum Sie viele Agenten orchestrieren sollten.

Die einfache Antwort lautet: Durch die Orchestrierung vieler Agenten können Sie mehr Arbeit erledigen.

Und dann fragen Sie sich vielleicht, warum nicht jeder einfach eine Reihe von Agenten orchestriert? Der Grund dafür ist, dass es bei der Ausführung vieler Agenten einige Herausforderungen gibt:

• Wie definieren und fassen Sie spezifische Aufgaben zusammen, an denen verschiedene Agenten arbeiten können, damit sich die Agenten nicht gegenseitig in ihrer Arbeit behindern?
• Wie behalten Sie den Überblick über alle Ihre Agenten?
• Wie beantworten Sie alle Anfragen, wenn die Agenten Fragen an Sie haben? Und wie erfassen Sie den Kontext jedes Agenten, wenn Sie dem Agenten eine Antwort geben müssen?

All dies sind Herausforderungen, die es schwierig machen, viele Agenten gleichzeitig zu orchestrieren. Es gibt jedoch Möglichkeiten, mehr Agenten zu orchestrieren, und die Antwort besteht im Wesentlichen darin, eine Abstraktionsebene nach oben zu verschieben. Sie müssen zu einer Ebene wechseln, auf der Sie mit einem Agenten sprechen, der wiederum mehrere andere Agenten koordinieren kann.

Das ist das Thema, über das ich heute sprechen werde. Ich werde nicht mit Claude Code oder Codex darüber diskutieren, Subagenten zu betreiben. Ich werde im wahrsten Sinne des Wortes diskutieren, wie man mehrere Claude Code- oder Codex-Sitzungen gleichzeitig ausführen kann.

So orchestrieren Sie viele Agenten

Headless-Sitzungen starten

Die kurze Antwort auf die Frage, wie man viele Agenten orchestrieren kann, ist die Verwendung des Headless-Modus.

Der Headless-Modus in Claude Code und Codex ist im Grunde ein Modus, in dem Sie über die CLI eine Sitzung starten und den Agenten an einer bestimmten Aufgabe arbeiten lassen können, ohne sich dann mit der Antwort bei Ihnen zu melden.

Ich nutze dies häufig, um beispielsweise Codeüberprüfungen mit Codex durchzuführen. Dieses Thema habe ich in zahlreichen früheren Artikeln behandelt und ist eine der effektivsten Techniken, die ich habe, um die Anzahl der Fehler in Ihrer Anwendung zu reduzieren.

Sie können den Headless-Modus mit Claude Code aktivieren, indem Sie:

claude -p "your immediate right here"

Und Sie können den Headless-Modus mit Codex aktivieren, indem Sie:

codex exec "your immediate right here"

Sobald Sie dies ausführen, starten Sie eine völlig separate Codex- oder Claude-Code-Sitzung, und diese Sitzung arbeitet mit dem von Ihnen angegebenen Befehl, bis die Aufgabe abgeschlossen ist. Der Orchestrator-Agent, mit dem Sie sprechen, sieht die Protokolle dann nur, wenn er dies wünscht, und das Endergebnis des Befehls ist die Ausgabe des Agenten, beispielsweise wenn die Arbeit abgeschlossen wurde. Eine Beispielantwort, die Sie möglicherweise vom Agenten erhalten, ist:

The duty was mounted and merged to dev.

Normalerweise fügen Sie beim Ausführen des Befehls möglicherweise auch einige andere Einstellungen hinzu, z. B. die Möglichkeit, die Agenten auszuführen, ohne nach Berechtigungen zu fragen. Zulassen von Werkzeugen, Festlegen der maximalen Umdrehungen, Angeben des zu verwendenden Modells usw.

Mit dem Headless-Modus effektiv sein

Ich werde drei Haupttechniken behandeln, um im Headless-Modus effektiv zu sein:

• Bereitstellung einer Möglichkeit für den Agenten, seine eigene Arbeit zu überprüfen
• Passende Aufgaben für Headless-Modi finden, wie zum Beispiel Refactoring
• Geben Sie dem Agenten alle Werkzeuge, die er benötigt

Bereitstellung einer Möglichkeit für den Agenten, seine eigene Arbeit zu überprüfen

Eine Sache ist natürlich, viele Sitzungen und Agenten im Headless-Modus starten zu können. Eine andere Sache, die natürlich wichtig ist, ist: Wie können Sie mit solchen Mitteln effektiv arbeiten?

Eine der Herausforderungen besteht darin, dass Sie nicht direkt in alle Entscheidungen einbezogen werden können. Da Sie eine Abstraktionsebene nach oben verschieben, müssen Sie die Agenten dazu bringen, mehr Entscheidungen zu treffen. Das gibt Ihnen in gewisser Weise weniger Kontrolle. Daher müssen Sie die Artwork und Weise ändern, wie Sie das Modell auf eine höhere Ebene veranlassen, und Sie müssen ihm mitteilen, wie es seine Funktion überprüfen soll.

Wir kommen wieder auf dasselbe Thema zurück, das ich bereits ausführlich behandelt habe, und betonen, wie Sie den Agenten Möglichkeiten zur Überprüfung der Arbeit bieten müssen.

Passende Aufgaben für Headless-Modi finden, wie zum Beispiel Refactoring

Ein weiterer wichtiger Punkt bei der Verwendung solcher Agenten besteht darin, sie auf Aufgaben anzuwenden, die sich intestine für den Headless-Modus eignen. Kompliziertere Aufgaben eignen sich nicht für den Headless-Modus und sind wahrscheinlich besser dran, wenn Sie mehr Eingaben vornehmen. Auch bei Aufgaben, die sehr vage sind und bei denen Sie selbst nicht alles verstehen, sollten Sie auch direkt mit den Programmieragenten interagieren

Eine Aufgabe, die sich jedoch besonders intestine für den Headless-Modus eignet, ist das Refactoring.

Nach der Veröffentlichung von Claude Fable nutzte ich es natürlich, um Probleme und Refactoring-Möglichkeiten in meinem Code zu erkennen und meine Codierungsagenten effektiver zu machen. Dabei kann es sich um die Entdeckung von Problemen handeln wie:

• Schlechte Trennung der Anliegen
• Sicherheitslücken
• Schlechte Architekturentscheidungen

Sie können dies jetzt ganz einfach mit dem folgenden Befehl tun:

search for refactor alternatives on this repository and supply 
them to me in a prioritized method in an HTML file and make a plan on how 
to repair it

Dadurch werden mit ziemlicher Sicherheit eine Reihe von Problemen gefunden, die Sie unbedingt beheben sollten, insbesondere wenn Sie die leistungsstärksten verfügbaren Codierungsagenten wie Claude Fable verwenden.

Nachdem Sie dies getan haben, haben Sie einen vollständigen Plan. Sie sollten diesen Plan nun mit der folgenden Eingabeaufforderung konvertieren

Take the plan <path to plan> and construction a approach for us to implement it. 
I will be utilizing essentially the most highly effective coding agent as an orchestrator, and that 
coding agent ought to spin up a bunch of Claude Code headless periods utilizing 
Claude Opus to get every particular person activity accomplished. Guarantee that duties that 
will be accomplished in parallel are spun up in parallel and proceed working till 
you end the refactoring utterly.

Ich habe dies in den letzten Tagen verwendet, nachdem Fable mit dem Claude Code-Abonnement wieder verfügbar conflict, und ich denke, es hat wirklich intestine funktioniert. Erstens musste ich nicht selbst viele Claude-Code-Sitzungen mit all den Aufgaben und Refactoring-Möglichkeiten starten, die der Agent entdeckt, und es conflict tatsächlich sehr effektiv, Dinge in die Produktion zu bringen.

Geben Sie dem Agenten alle Werkzeuge, die er benötigt

Schließlich ist es auch wichtig, dem Agenten alle Werkzeuge zur Verfügung zu stellen, die er benötigt. Wenn Sie Claude im Headless-Modus ausführen, ist es für den Orchestrierungsagenten schwierig, mit ihm zu interagieren, und Sie möchten nur minimale Interaktionen. Das Ziel des Headless-Modus besteht einfach darin, eine One-Cease-Store-Eingabeaufforderung bereitzustellen, die einige Arbeiten erledigt und zurückmeldet, wenn sie erledigt sind, genau wie ein normaler Subagent, aber natürlich noch leistungsfähiger. Wenn Sie dies wünschen, müssen Sie dem Agenten alle erforderlichen Instruments zur Verfügung stellen. Es benötigt möglicherweise MCP-Zugriff, es muss auf jeden Fall erlaubt sein, Aktionen autonom auszuführen, und so weiter. Daher empfehle ich Ihnen dringend, den Agenten natürlich viel Freiheit zu geben und gleichzeitig die Kontrolle über sie zu behalten, damit sie ihre Arbeit autonom ausführen und ihrem orchestrierenden Agenten Bericht erstatten können, wenn sie fertig sind.

Abschluss

In diesem Artikel habe ich erläutert, wie man mehr als 100 Agenten orchestriert, indem man Agenten als Orchestrierungsagenten einsetzt, um eine Reihe anderer Agenten zu starten. Ich glaube, dass dies eine sehr leistungsstarke Technik ist, die Sie sofort auf Ihre eigene Codierung anwenden können, um sich einen enormen Vorteil zu verschaffen und mit Ihrer Programmierung noch produktiver zu werden. Ich verwende diese Technik täglich, um Hunderte von Agenten parallel arbeiten zu lassen und ihre Arbeit zu erledigen. Ich glaube, dass die Zukunft der Programmierung einfach darin bestehen wird, dass wir die Abstraktionsebenen immer weiter nach oben bewegen, und die Techniken, die ich in diesem Artikel vorgestellt habe, sind eine Möglichkeit, eine Abstraktionsebene über Ihre normalen Claude-Code-Interaktionen hinaus zu erreichen.

Nehmen Sie Kontakt auf

Mein kostenloses E-Guide und Webinar:

Verzehnfachen Sie Ihr Engineering mit LLMs (kostenloser 3-tägiger E-Mail-Kurs)

Holen Sie sich mein kostenloses E-Guide „Imaginative and prescient Language Fashions“.

Mein Webinar zu Imaginative and prescient Language Fashions

Finden Sie mich in den sozialen Netzwerken:

Unterstapel

LinkedIn

X / Twitter