Die Möglichkeit, viele Codierungsagenten parallel auszuführen, besteht darin, sicherzustellen, dass Sie über lange laufende Sitzungen verfügen. Das bedeutet Sitzungen, die so wenig wie möglich unterbrochen werden. Fragen Sie beispielsweise nach menschlichen Eingaben, Berechtigungen usw.

Frontier-Coding-Agenten werden immer besser darin, über längere Zeiträume zu arbeiten und sind immer bestrebter, die Ziele zu erreichen, die sie durch den menschlichen Enter erhalten. Das fällt mir besonders beim neuesten Claude Fable-Modell und GPT-5.6 auf.

Die Agenten allein lösen jedoch nicht alles. Sie müssen außerdem über eine Systematik und Struktur rund um Ihre Codierung verfügen, die sicherstellt, dass die Brokers über längere Zeiträume ausgeführt werden können. In diesem Artikel werde ich Folgendes besprechen:

• So erstellen Sie eine Umgebung, in der Agenten über längere Zeiträume ausgeführt werden können
• So erteilen Sie ihnen die Berechtigungen, die sie benötigen
• So stellen Sie sicher, dass Agenten ihre eigene Arbeit überprüfen.

Warum Langzeitagenten betreiben?

Zunächst möchte ich erläutern, warum Sie die Tipps in diesem Artikel befolgen sollten. In diesem Fall geht es darum, warum Sie Agenten über einen längeren Zeitraum betreiben sollten. Sie denken vielleicht, Sie möchten, dass Agenten schnell arbeiten und ihre Arbeit so schnell wie möglich erledigen. Natürlich möchte man bis zu einem gewissen Grad, dass Dinge so schnell wie möglich erledigt werden, aber es gibt hier auch einen Kompromiss darin, wie viel ein Mensch mit dem Agenten interagieren muss, um die Arbeit zu erledigen.

Nach der Veröffentlichung von Codierungsagenten und insbesondere nachdem diese sehr leistungsfähig geworden sind, nach der Veröffentlichung von Claude Opus 4.5, ist der Engpass bei der Codierung zur menschlichen Überprüfungszeit geworden; Das heißt, es ist nicht die eigentliche Implementierung des Codes, die Zeit braucht; Es geht vielmehr darum, die Ergebnisse des Codes zu überprüfen und zu überprüfen, ob er korrekt und gemäß den Spezifikationen implementiert ist, was Zeit kostet. Da dies der Engpass ist, möchten Sie den Zeitaufwand für die Überprüfung minimieren. Aus diesem Grund möchten Sie, dass die Agenten über längere Zeiträume laufen, alles implementieren und überprüfen, bevor sie es an den Menschen übergeben.

Dies minimiert die Zeit, die ein Mensch für die Überprüfung einer Aufgabe aufwenden muss, was excellent ist, da dies derzeit den Engpass bei der Programmierung darstellt.

Einfach erklärt:

Sie wünschen sich langwierige Agenten, da die menschliche Überprüfung jetzt den Engpass darstellt, und Sie möchten den Zeitaufwand für die menschliche Überprüfung so gering wie möglich halten, um so viel Arbeit wie möglich zu erledigen.

So führen Sie Agenten länger als 24 Stunden aus

Nun gehe ich auf einige spezifischere Techniken und Tipps ein, wie man Agenten tatsächlich über längere Zeiträume laufen lässt. Als allgemeinen Überblick werde ich diese Techniken und Tipps behandeln.

• Erteilen Sie Agenten alle Berechtigungen
• Geben Sie Agenten die Möglichkeit, ihre eigene Arbeit zu überprüfen
• Lassen Sie Agenten den Code überprüfen (Codex)
• Ausführen von Agenten aus der Ferne

Berechtigungen

Als Erstes können Sie sofort damit beginnen, sicherzustellen, dass die Agenten über alle Berechtigungen verfügen, die sie benötigen. Wenn ein Agent aufhören muss, um Berechtigungen zu bitten, verschwenden Sie viel Zeit und in quick allen Fällen ist es einfach etwas, das Sie ohnehin akzeptieren. Es gibt zahlreiche Möglichkeiten, dies zu tun, und Sie können den automatischen Modus aktivieren oder alle Berechtigungen überspringen. Diese Einstellungen sind sowohl in Codex als auch in Claude Code verfügbar. Beachten Sie möglicherweise, dass Sie im Sandbox-Modus arbeiten sollten, um Ihren Laptop und Ihre Daten zu schützen und sicherzustellen, dass nichts dauerhaft gelöscht wird.

Ich denke, es lohnt sich auch zu wissen, dass OpenAI kürzlich tatsächlich zugegeben hat, dass es Situationen gab, in denen das neueste GPT-Modell unter ganz bestimmten Umständen eine Reihe von Dateien von den Computern anderer gelöscht hat. Das kommt natürlich sehr selten vor und wird Ihnen höchstwahrscheinlich nie passieren, aber wenn es passiert, können die Folgen natürlich ziemlich schwerwiegend sein.

Es gibt zahlreiche Möglichkeiten, sich davor zu schützen. Eine besteht natürlich darin, die Agenten in einer Sandbox auszuführen, damit sie keine Dinge außerhalb ihres eigenen Arbeitsbereichs, in dem sie arbeiten oder aktiv sind, löschen können. Eine andere Sache ist, alles auf Ihrem Laptop zu sichern. Sie sollten natürlich Ihren gesamten Code haben und wenn möglich in GitHub arbeiten. Dies ist sowohl für die sichere Speicherung als auch für die Versionierung von Vorteil, was sehr nützlich sein kann. Und insgesamt führen Sie Backups auf Ihrem Laptop durch, zum Beispiel mit Time Machine auf dem Mac. Dies schützt Sie vor solchen Situationen.

Arbeit überprüfen

Ein weiterer sehr wichtiger Punkt besteht darin, sicherzustellen, dass die Agenten ihre eigene Arbeit überprüfen können. Dies ist ein Thema, das ich bereits in mehreren anderen Artikeln besprochen habe, aber es kommt darauf an, wie Sie Ihrem Agenten eine Aufgabe beschreiben und welche Instruments Sie den Agenten zur Verfügung stellen.

Wenn Sie dem Agenten eine Aufgabe beschreiben, müssen Sie sicherstellen, dass Sie so detaillierte Anweisungen wie möglich geben und tatsächlich erwähnen, was Sie erreichen möchten. Am wichtigsten ist jedoch, dass Sie dem Agenten sagen, woran er erkennen kann, wann seine Arbeit abgeschlossen ist. Und der beste Weg, dies zu tun, besteht normalerweise darin, dem Agenten mitzuteilen, wie er die Implementierung testen soll.

Um ein Beispiel zu nennen: Nehmen wir an, Sie möchten einen bestimmten Entwurf umsetzen, der Ihnen übergeben wurde. In diesem Fall sollten Sie dem Agenten mitteilen, dass das Design genau so implementiert werden muss, wie es ist, und dass der Agent die Arbeit überprüfen soll, indem er Screenshots des Designs und Screenshots seiner eigenen Implementierung erstellt, diese vergleicht und sicherstellt, dass sie gleich sind. Darüber hinaus sollten Sie ihm mitteilen, dass er Sie auf eventuelle Abweichungen zwischen dem Entwurf und der Umsetzung aufmerksam machen soll, damit Sie Entscheidungen treffen können.

Der Grund, warum Sie diesen letzten Teil benötigen, liegt darin, dass Designs häufig Teile enthalten, die angesichts Ihrer Codebasis technisch nicht realisierbar sind. Und für einen Designer ist es sehr schwierig, all dies zu berücksichtigen. Daher kann es in manchen Situationen zu Unstimmigkeiten kommen, die berücksichtigt und behoben werden müssen. Aber Sie sollten Ihren Codierungsagenten veranlassen, Sie darauf aufmerksam zu machen, wenn sie erscheinen, andernfalls sollte es genau gleich sein. Anschließend gewähren Sie dem Agenten Browserzugriff, beispielsweise auf Chrome, damit dieser sowohl das Design als auch seine Umsetzung in Chrome öffnen, Screenshots erstellen und seine eigene Arbeit überprüfen kann.

Sie können eine ähnliche Philosophie grundsätzlich auf alle anderen Aufgaben innerhalb der Programmierung anwenden. Beschreiben Sie eine Aufgabe im Element, worüber Sie nachdenken sollten und wie der Agent seine eigene Arbeit überprüfen soll, indem er beispielsweise Screenshots erstellt oder eine Testsuite ausführt usw.

Überprüfung des Agentencodes

Der letzte Abschnitt, in dem ich erläutere, wie man die Arbeit verifiziert, ist sehr nützlich, kann aber auch etwas schwierig umzusetzen sein, da Sie Agenten auf bestimmte Weise auffordern und ihnen Zugriff auf alle Instruments gewähren müssen, die sie benötigen. Der nächste Abschnitt hier mit einer Überprüfung des Agentencodes ist weitaus einfacher.

Grundsätzlich sollten Sie eine Möglichkeit einrichten, dass die Agenten ihren eigenen Code überprüfen, sodass Sie die manuelle Überprüfung nicht durchführen müssen. Meiner Meinung nach müssen Sie, wenn Sie dies richtig machen, quick überhaupt keine menschliche Codeüberprüfung durchführen, es sei denn, es handelt sich um sehr, sehr kritische Teile Ihrer Anwendungen, bei denen Sie sich keinen Fehler leisten können. Der Grund dafür ist, dass ich glaube, dass die Codierungsagenten so intestine darin geworden sind, Code zu überprüfen, dass sie im Grunde alle Fehler beseitigen, die dadurch entstehen, dass neuer Code in die Produktion geschoben wird.

Meiner Meinung nach ist Codex der beste Bewertungsagent. Sie können damit auf zwei Arten eine Überprüfung durchführen. Erstens können Sie die GitHub-Assessment-Implementierung verwenden, die Codex selbst hat, wo Sie sie aktivieren und Codex einfach in einer PR taggen, und es wird automatisch kommen und den Code überprüfen. Die zweite Möglichkeit besteht darin, es über die CLI auszuführen, wo Sie Codex grundsätzlich dazu veranlassen können, eine Überprüfung für einen Zweig durchzuführen und ihn mit einem anderen Zweig zu vergleichen. Sie richten es additionally einfach auf zwei Filialen und es führt eine Überprüfung für Sie durch. Normalerweise verwende ich den zweiten Weg, weil er meiner Erfahrung nach schneller ist und es oft zu Verzögerungen bei der Git-Überprüfung kommt, wenn Codex auf GitHub markiert ist.

Dadurch sparen Sie enorm viel Zeit und können deutlich mehr Code in die Produktion bringen.

Agenten aus der Ferne ausführen

Eine letzte Sache, die ich erwähnen möchte, ist, dass Sie Agenten benötigen, die über eine lange Laufzeit laufen und die distant ausgeführt werden können. Dies bedeutet im Grunde, dass Agenten nicht unterbrochen werden, wenn Sie Ihren Laptop schließen. Dieses Setup hat Vor- und Nachteile. Ein Vorteil der lokalen Ausführung von Agenten auf Ihrem Laptop ist natürlich, dass Sie vollen Zugriff darauf haben. Sie können die Browser-Interaktionen, die die Agenten ausführen, ganz einfach sehen oder ganz einfach überprüfen, was die Agenten tun. Und es ist auch nur eine einfachere Einrichtung. Die lokale Ausführung der Agenten ist einfacher als die Distant-Ausführung. Allerdings hat die Fernsteuerung von Agenten auf jeden Fall auch einige sehr große Vorteile.

Wenn Sie sie lokal ausführen, besteht die Gefahr, dass sie unterbrochen werden. Wenn Sie beispielsweise Ihren Laptop schließen, wenn Sie von der Arbeit nach Hause gehen oder auf Reisen sind und Ihren Laptop schließen müssen, werden die Agenten unterbrochen. Nun kann man auf dem Mac zum Beispiel den Ruhezustand deaktivieren, wenn man den Deckel des Computer systems schließt, aber meiner Erfahrung nach wird der Laptop dadurch sehr heiß, und ich empfehle das nicht. Hat nicht sehr intestine funktioniert, als ich es ausprobiert habe.

Wenn Sie jedoch Distant-Agenten haben, werden diese natürlich nicht unterbrochen, da sie entweder in der Cloud oder auf einem anderen Laptop ausgeführt werden, der immer eingeschaltet und nie geschlossen ist. Der Nachteil dabei ist natürlich, dass Sie weniger Überblick darüber haben, was die Agenten genau tun, und die Einrichtung kann etwas umständlich sein, obwohl Sie Claude Code oder Coding-Agenten verwenden können, um die Einrichtung recht einfach durchzuführen.

Für mein Setup verfüge ich über einen leistungsstarken Laptop, den ich auf Reisen verwende und auf dem ich die meisten meiner Agenten betreibe. Allerdings habe ich auch einen sekundären Laptop, auf dem meine Bots laufen, meine OpenClaw-Bots, damit sie jederzeit arbeiten können, und ich kann auch Claude Code oder Codex-Sitzungen auf diesem Laptop starten, sodass sie auf unbestimmte Zeit laufen, wenn ich möchte, dass Aufgaben ohne Unterbrechung ausgeführt werden. Das kann sehr nützlich sein. Eine letzte Various besteht darin, es irgendwo in der Cloud auszuführen, aber das hat auch Nachteile. Zunächst einmal müssen Sie Dokumente oder Geheimnisse in der Cloud speichern, was riskant sein kann und etwas, das ich persönlich vermeiden möchte. Und ja, im Grunde ist die Einrichtung auch etwas umständlich.

Abschluss

In diesem Artikel habe ich besprochen, wie Sie Agenten über längere Zeiträume ausführen können. Ich habe besprochen, warum dies wichtig ist, und hervorgehoben, wie Sie dadurch als Ingenieur mehr Arbeit leisten können. Darüber hinaus habe ich spezifische Techniken behandelt, die es Agenten ermöglichen, über einen längeren Zeitraum ausgeführt zu werden, einschließlich der Gewährung der erforderlichen Berechtigungen an die Agenten, der Erläuterung, wie sie ihre eigene Arbeit überprüfen, wie sie eine Überprüfung des Agentencodes durchführen und wie Sie Agenten aus der Ferne ausführen können, um sicherzustellen, dass sie nie unterbrochen werden. Ich glaube, dass alle diese Techniken sehr wichtig sind, und Sie sollten mit deren Implementierung beginnen, um sicherzustellen, dass Ihre Agenten so lange wie möglich autonom arbeiten können, bis sie ihre Arbeit abgeschlossen haben. Darüber hinaus glaube ich auch, dass die Distant-Ausführung von Agenten in Zukunft immer beliebter werden wird, wenn man bedenkt, dass es nicht wirklich sinnvoll ist, alles auf Ihrem lokalen Laptop auszuführen, da dieser unweigerlich zu einem bestimmten Zeitpunkt heruntergefahren wird, was Ihre Agenten unterbrechen wird. Das ist additionally definitiv eine Richtung, auf die man achten sollte.

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

Reinforcement Studying – Lernen aus Beobachtungen und Belohnungen – ist die Methode, die der Artwork und Weise, wie Menschen (und Tiere) lernen, am ähnlichsten ist.

Trotz dieser Ähnlichkeit bleibt es auch der komplizierteste und problematischste Bereich des modernen maschinellen Lernens. Um den berühmten Andej Karpathy zu zitieren:

Reinforcement Studying ist schrecklich. Es ist einfach so, dass alles, was wir vorher hatten, viel schlimmer struggle.

Um das Verständnis der Methode zu erleichtern, werde ich ein Schritt-für-Schritt-Beispiel eines Agenten erstellen, der mithilfe von Q-Studying lernt, in einer Umgebung zu navigieren. Der Textual content beginnt mit den ersten Prinzipien und endet mit einem voll funktionsfähigen Beispiel, das Sie in der Unity-Spiel-Engine ausführen können.

Für diesen Artikel sind Grundkenntnisse der Programmiersprache C# erforderlich. Wenn Sie mit der Unity-Spiel-Engine nicht vertraut sind, bedenken Sie einfach, dass jedes Objekt ein Agent ist, der:

• ausführt Begin() einmal zu Beginn des Programms,
• Und Replace() kontinuierlich parallel zu den anderen Agenten.

Das zugehörige Repository für diesen Artikel ist verfügbar GitHub. Alle Bilder stammen vom Autor, sofern nicht anders angegeben.

Was ist Reinforcement Studying?

Beim Reinforcement Studying (RL) haben wir einen Agenten, der in der Lage ist, Maßnahmen zu ergreifen, die Ergebnisse dieser Maßnahmen zu beobachten und aus Belohnungen/Strafen für diese Maßnahmen zu lernen.

Die Artwork und Weise, wie ein Agent in einem bestimmten Zustand über eine Aktion entscheidet, hängt von ihm ab Politik. Eine Politik π ist eine Funktion, die das Verhalten eines Agenten definiert und Zustände Aktionen zuordnet. Gegeben eine Reihe von Zuständen S und eine Reihe von Aktionen A Eine Richtlinie ist eine direkte Zuordnung: π: S → A .

Wenn wir außerdem möchten, dass der Agent mehr mögliche Optionen mit einer Auswahl hat, können wir eine erstellen Stochastische Politik. Dann bestimmt eine Richtlinie anstelle einer einzelnen Aktion die Wahrscheinlichkeit, jede Aktion in einem bestimmten Zustand zu ergreifen: π: S × A → (0, 1).

Beispiel für einen navigierenden Roboter

Um den Lernprozess zu veranschaulichen, erstellen wir ein Beispiel eines navigierenden Roboters in einer 2D-Umgebung und verwenden dabei eine von vier Aktionen: A = {Left, Proper, Up, Down} . Der Roboter muss zu jedem Zeitpunkt auf der Karte den Weg zur Auszeichnung finden, ohne ins Wasser zu fallen.

Die Belohnungen werden zusammen mit den Kacheltypen mithilfe einer Enum codiert:

public enum TileEnum { Water = -1, Grass = 0, Award = 1 }

Der Zustand wird durch seine Place im Raster angegeben, was bedeutet, dass wir 40 mögliche Zustände haben: S = (0…7) × (0…4) (ein 8 × 5-Kachelgitter), das wir mithilfe eines 2D-Arrays codieren:

_map = {
    { -1, -1, -1, -1, -1, -1, -1, -1 },   // all water border
    { -1,  0,  0,  0, -1,  0,  1, -1 },   // 1 = Award (trophy)
    { -1,  0,  0,  0, -1,  0,  0, -1 },
    { -1,  0,  0,  0,  0,  0,  0, -1 },
    { -1, -1, -1, -1, -1, -1, -1, -1 },   // all water border
}

Wir speichern die Karte in einer Kachel TileGrid das die folgenden Hilfsfunktionen hat:

// Acquire a tile at a coordinate
public T GetTileByCoords<T>(int x, int y);

// Given a tile and an motion, get hold of the following tile
public T GetTargetTile<T>(T supply, ActionEnum motion);

// Create a tile grid from the map
public void GenerateTiles();

Wir werden verschiedene Kacheltypen verwenden, daher das Allgemeine T. Jede Kachel hat eine TileType gegeben durch die TileEnum und daher auch seine Belohnung, die als erhalten werden kann (int) TileType.

Die Bellman-Gleichung

Das Downside, eine optimale Richtlinie zu finden, kann mithilfe von iterativ gelöst werden Bellman-Gleichung. Die Bellman-Gleichung postuliert, dass die langfristige Belohnung einer Aktion gleich der unmittelbaren Belohnung für diese Aktion ist Plus die erwartete Belohnung aller zukünftigen Aktionen.

Es kann iterativ für Systeme mit diskreten Zuständen und diskreten Zustandsübergängen berechnet werden. Haben:

• s— aktueller Stand,
• A— Menge aller Aktionen,
• s'— Zustand, der durch das Ergreifen einer Aktion erreicht wird a im Staat s ,
• γ— Abzinsungsfaktor (je weiter die Belohnung, desto geringer ihr Wert),
• R(s, a)— sofortige Belohnung für das Handeln a im Staat s

Die Bellman-Gleichung gibt dann den Wert an V(s) eines Staates s Ist:

Iteratives Lösen der Bellman-Gleichung

Die Berechnung der Bellman-Gleichung ist ein dynamisches Programmierproblem. Bei jeder Iteration nberechnen wir die erwartete zukünftige Belohnung, die in erreichbar ist n+1 Schritte für alle Kacheln. Für jede Kachel speichern wir dies mit a Worth Variable.

Wir vergeben eine Belohnung basierend auf dem Zielplättchen, d. h 1 wenn die Auszeichnung erreicht wird, -1 im Roboter fällt ins Wasser, und 0 ansonsten. Sobald entweder Auszeichnung oder Wasser erreicht sind, sind keine Aktionen mehr möglich, daher bleibt der Wert des Zustands auf dem Anfangswert 0 .

Wir erstellen einen Supervisor, der das Raster generiert und die Iterationen berechnet:

non-public void Begin()
{
    tileGrid.GenerateTiles();
}

non-public void Replace()
{       
    CalculateValues();
    Step();
}

Um den Überblick über die Werte zu behalten, verwenden wir a VTile Klasse, die a enthält Worth. Um zu vermeiden, dass aktualisierte Werte direkt übernommen werden, legen wir zunächst fest NextValue und stellen Sie dann alle Werte auf einmal im ein Step() Funktion.

non-public float gamma = 0.9; // Discounting issue

// The Bellman equation 
non-public double GetNewValue(VTile tile)
{
    return Agent.Actions
        .Choose(a => tileGrid.GetTargetTile(tile, a))
        .Choose(t => t.Reward + gamma * t.Worth) // Reward in (1, 0, -1)
        .Max();
}

// Get subsequent values for all tiles
non-public void CalculateValues()
{
    for (var y = 0; y < TileGrid.BOARD_HEIGHT; y++)
    {
        for (var x = 0; x < TileGrid.BOARD_WIDTH; x++)
        {
            var tile = tileGrid.GetTileByCoords<VTile>(x, y);
            if (tile.TileType == TileEnum.Grass)
            {
                tile.NextValue = GetNewValue(tile);
            }
        }
    }
}

// Copy subsequent values to present values (iteration step)
non-public void Step()
{
    for (var y = 0; y < TileGrid.BOARD_HEIGHT; y++)
    {
        for (var x = 0; x < TileGrid.BOARD_WIDTH; x++)
        {
            tileGrid.GetTileByCoords<VTile>(x, y).Step();
        }
    }
}

Bei jedem Schritt der Wert V(s) Der Wert jedes Plättchens wird über alle Aktionen hinweg auf das Most der unmittelbaren Belohnung plus dem reduzierten Wert des resultierenden Plättchens aktualisiert. Die zukünftige Belohnung breitet sich vom Auszeichnungsplättchen nach außen aus, wobei die abnehmende Rendite von gesteuert wird γ = 0.9 .

Aktionsqualität (Q-Werte)

Wir haben einen Weg gefunden, Zustände mit Werten zu verknüpfen, was für dieses Wegfindungsproblem ausreicht. Hierbei steht jedoch die Umgebung im Mittelpunkt und der Agent wird außer Acht gelassen. Für einen Agenten möchten wir normalerweise wissen, was in der Umgebung eine gute Aktion wäre.

Im Q-Studying wird dieser Wert einer Aktion als ihr bezeichnet Qualität (Q-Wert). Jede (state, motion) Dem Paar wird ein einzelner Q-Wert zugewiesen.

Wo der neue Hyperparameter α definiert eine Lernrate – wie schnell neue Informationen alte überschreiben. Dies ist analog zum standardmäßigen maschinellen Lernen und die Werte sind normalerweise ähnlich, hier verwenden wir 0.005 . Anschließend berechnen wir den Nutzen einer Maßnahme anhand der zeitlichen Differenz D(s,a):

Da wir nicht mehr alle Aktionen im aktuellen Zustand betrachten, sondern die Qualität jeder Aktion einzeln, maximieren wir nicht über alle möglichen Aktionen im aktuellen Zustand, sondern über alle möglichen Aktionen in dem Zustand, den wir erreichen werden, nachdem wir die Aktion ausgeführt haben, deren Qualität wir berechnen, kombiniert mit der Belohnung für die Durchführung dieser Aktion.

Der zeitliche Differenzterm kombiniert die unmittelbare Belohnung mit der bestmöglichen zukünftigen Belohnung und ist somit eine direkte Ableitung der Bellman-Gleichung (siehe Wiki für Particulars).

Um den Agenten zu trainieren, instanziieren wir erneut ein Raster, aber dieses Mal erstellen wir auch eine Instanz des Agenten, platziert unter (2,2).

non-public Agent _agent;

non-public void ResetAgentPos()
{
    _agent.State = tileGrid.GetTileByCoords<QTile>(2, 2);
}

non-public void Begin()
{
    tileGrid.GenerateTiles();
    _agent = Instantiate(agentPrefab, rework);
    ResetAgentPos();
}

non-public void Replace()
{
    Step();
}

Ein Agent Objekt hat einen aktuellen Zustand QState. Jede QStatebehält den Q-Wert für jede verfügbare Aktion bei. Bei jedem Schritt aktualisiert der Agent die Qualität jeder im Standing verfügbaren Aktion:

non-public void Step() 
{
  if (_agent.State.TileType != TileEnum.Grass)
  {
      ResetAgentPos();
  }
  else
  {
      QTile s = _agent.State;
  
      // Replace Q-values for ALL actions from present state
      foreach (var a in Agent.Actions)
      {
          double q = s.GetQValue(a);
          QTile sPrime = tileGrid.GetTargetTile(s, a);
          double r = sPrime.Reward;
          double qMax = Agent.Actions.Choose(sPrime.GetQValue).Max();
          double td = r + gamma * qMax - q;
          s.SetQValue(a, q + alpha * td);
      }
  
      // Take the most effective obtainable motion a
      ActionEnum chosen = PickAction(s); 
      _agent.State = tileGrid.GetTargetTile(s, chosen);
  }
}

Ein Agent verfügt über eine Reihe möglicher Maßnahmen in jedem Bundesstaat und wird in jedem Bundesstaat die besten Maßnahmen ergreifen.

Gibt es mehrere beste Aktionen, wird eine davon zufällig ausgewählt, da wir die Aktionen zuvor gemischt haben. Aufgrund dieser Zufälligkeit verläuft jedes Coaching anders, stabilisiert sich jedoch im Allgemeinen zwischen 500 und 1000 Schritten.

Dies ist die Grundlage von Q-Studying. Anders als die ZustandswerteDie Aktionsqualität kann in Situationen angewendet werden, in denen:

• die Beobachtung ist jeweils unvollständig (Sichtfeld des Agenten)
• die Beobachtung ändert sich (Objekte bewegen sich in der Umgebung)

Exploration vs. Ausbeutung (ε-Grasping)

Bisher hat der Agent jedes Mal die bestmögliche Aktion durchgeführt, was jedoch dazu führen kann, dass der Agent schnell in einem lokalen Optimum stecken bleibt. Eine zentrale Herausforderung beim Q-Studying ist der Kompromiss zwischen Exploration und Exploitation:

• Ausnutzen – Wählen Sie die Aktion mit dem höchsten bekannten Q-Wert (gierig).
• Erkunden – Wählen Sie eine zufällige Aktion aus, um potenziell bessere Pfade zu entdecken.

ε-Gierige Politik

Gegeben ein zufälliger Wert r ∈ (0, 1) und Parameter epsilon Es gibt zwei Möglichkeiten:

• Wenn r > epsilon Wählen Sie dann die beste Aktion aus (ausbeuten),
• andernfalls wählen Sie eine zufällige Aktion (erkunden).

Verfallendes Epsilon

Normalerweise möchten wir frühzeitig mehr erforschen und später mehr ausnutzen. Dies wird durch Zerfall erreicht epsilon im Laufe der Zeit:

epsilon = max(epsilonMin, epsilon − epsilonDecay)

Nach genügend Schritten konvergiert die Strategie des Agenten dahingehend, dass er quick immer die Aktion mit der höchsten Qualität auswählt.

non-public epsilonMin = 0.05;
non-public epsilonDecay = 0.005;

non-public ActionEnum PickAction(QTile state) {
  ActionEnum motion = Random.Vary(0f, 1f) > epsilon
      ? Agent.Actions.Shuffle().OrderBy(state.GetQValue).Final()  // exploit
      : Agent.RndAction();                                       // discover

  epsilon = Mathf.Max(epsilonMin, epsilon - epsilonDecay);
  return motion;
}

Das breitere RL-Ökosystem

Q-Studying ist ein Algorithmus innerhalb einer größeren Familie von Reinforcement Studying (RL)-Methoden. Algorithmen können entlang mehrerer Achsen kategorisiert werden:

• Zustandsraum: Diskret (z. B. Brettspiele) | Kontinuierlich (z. B. FPS-Spiele)
• Aktionsraum: Diskret (z. B. Strategiespiele) | Kontinuierlich (z. B. Autofahren)
• Richtlinientyp: Off-Coverage (Q-Studying: a’ ist immer maximiert) | Richtlinienkonform (SARSA: a’ wird durch die aktuelle Richtlinie des Agenten ausgewählt)
• Operator: Wert | Qualität | Vorteil A(s, a) = Q(s, a) − V(s)

Eine umfassende Liste der RL-Algorithmen finden Sie im Wikipedia-Seite zum Reinforcement Studying. Weitere Methoden wie das Behavioral Cloning sind dort nicht aufgeführt, kommen aber auch in der Praxis zum Einsatz. Reale Lösungen nutzen typischerweise erweiterte Varianten oder Kombinationen der oben genannten.

Q-Studying ist eine Off-Coverage-Methode mit diskretem Handeln. Die Ausweitung auf kontinuierliche Zustands-/Aktionsräume führt zu Methoden wie Deep Q-Networks (DQN), die die Q-Tabelle durch ein neuronales Netzwerk ersetzen.

Im Beispiel der Grid-Welt hat die Q-Tabelle |S| × |A| = 40 × 4 = 160 Einträge – perfekt überschaubar. Aber für ein Spiel wie Schach ist der Zustandsraum größer 10⁴⁴ Positionen, wodurch eine explizite Tabelle nicht gespeichert oder gefüllt werden kann. In solchen Fällen können neuronale Netze zur Komprimierung der Informationen eingesetzt werden.

Praktisches Verstärkungslernen in Spielen

Der obige Textual content soll eine grundlegende Einführung in das Konzept der Reinforcement Studying Brokers bieten. In der Praxis ist es natürlich unwahrscheinlich, dass Sie einen RL-Algorithmus manuell implementieren.

Die Unity-Engine stellt ein RL-Paket bereit ML-Agentendie z. B. zum Trainieren genutzt werden kann Autorennen. In den Frontier Labs wird die Erforschung von RL-Methoden in großem Maßstab unter Verwendung von Spielumgebungen durchgeführt, beispielsweise dem Versteckspiel:

Die Modelle aus diesen Labors haben in komplexen Brettspielen wie z. B. bereits den besten Spieler der Welt geschlagen Gehenschnelle Strategien wie Starcraft Und Dotaund sogar Spiele, die Kommunikation auf menschlicher Ebene erfordern, wie z Diplomatie.

Gesponserte Inhalte

In dieser Abacus AI-Rezension untersuchen wir, wie ChatLLM, der auf dem Abacus-Ökosystem basierende KI-Assistent, es Benutzern ermöglicht, mit Vibe-Codierung zu experimentieren, intelligente Agenten zu erstellen und mehrere KI-Workflows über eine einzige Schnittstelle zu verwalten.

TL;DR – Erstellen Sie Apps mit KI-Agenten, anstatt Code zu schreiben

• Die Plattform vereint mehrere KI-Instruments in einer Umgebung.
• ChatLLM fungiert als zentraler Assistent, der mit Coding-Agenten und Workflows verbunden ist.
• DeepAgent ermöglicht die Entwicklung natürlicher Sprache durch ein Konzept, das als Vibe Coding AI bekannt ist.
• Benutzer können schnell funktionierende Anwendungen, Automatisierungsworkflows und KI-Instruments erstellen.
• Die Preise beginnen bei etwa 10 $/Monat, was das Experimentieren relativ erschwinglich macht.

Es eignet sich am besten für schnelles Prototyping, Experimente und die schnelle Entwicklung KI-gestützter Instruments, obwohl komplexe Unternehmenssysteme immer noch die Aufsicht des Entwicklers erfordern.

Die Imaginative and prescient hinter Abacus AI

Viele KI-Instruments lösen heute ein einziges Downside. Einige helfen Ihnen beim Schreiben von Code. Andere generieren Inhalte oder automatisieren Arbeitsabläufe. Die Herausforderung besteht darin, dass reale Projekte in der Regel alle diese Fähigkeiten zusammen erfordern.

Das hier besprochene System versucht, dieses Downside zu lösen, indem es eine Infrastruktur bereitstellt, in der mehrere KI-Agenten an Aufgaben zusammenarbeiten. Anstatt zwischen separaten Instruments zu wechseln, interagieren Benutzer mit einer einzigen Schnittstelle, die Codierung, Datenverarbeitung, Recherche und Automatisierung übernimmt.

Diese Architektur ermöglicht Funktionen wie DeepAgentder sich weniger wie ein Chatbot, sondern eher wie ein Projektkoordinator verhält, der in der Lage ist, Bewerbungen zu generieren.

Das Interessante daran ist, dass sich die Plattform nicht nur auf Chat-Interaktionen konzentriert. Es ist darauf ausgelegt, echte Entwicklungsabläufe zu unterstützen, was bedeutet, dass es strukturierten Code generieren, Daten verwalten und bereitstellbare Anwendungen erstellen kann.

Schlüsselfunktionen

ChatLLM: Der zentrale KI-Assistent

ChatLLM fungiert als Hauptschnittstelle, über die Benutzer mit dem System interagieren. Anstatt eine Verbindung zu einem einzelnen Modell herzustellen, kann der Assistent je nach Aufgabe verschiedene Modelle nutzen.

In der Praxis bedeutet dies, dass Benutzer Aufgaben ausführen können wie:

• Themen recherchieren
• Code generieren
• Erstellen von Automatisierungsworkflows
• Analyse von Datensätzen
• Anwendungslogik erstellen

Der Assistent stellt außerdem eine direkte Verbindung zu anderen Instruments innerhalb der Plattform her, sodass Benutzer von der Konversation zur Ausführung wechseln können, ohne die Umgebung verlassen zu müssen.

Durch diese Integration fühlt sich das System eher wie ein Entwicklungsarbeitsbereich als wie ein einfacher Chatbot an.

DeepAgent: Ideen in Anwendungen verwandeln

Die interessanteste Funktion ist DeepAgent, die den Vibe-Coding-KI-Workflow unterstützt.

Anstatt Schritt für Schritt Code zu schreiben, beschreiben Benutzer in natürlicher Sprache, was sie erstellen möchten. Das System interpretiert diese Anweisungen und generiert die technischen Komponenten, die erforderlich sind, damit die Anwendung funktioniert.

Beim Testen des Instruments folgte der Prozess im Allgemeinen dieser Struktur:

1. Der Benutzer beschreibt die Idee.
2. Das System stellt klärende Fragen.
3. Es wird ein Architekturplan erstellt.
4. Backend- und Frontend-Code werden erstellt.
5. Es wird eine vorschaubare Anwendung erstellt.

Dieser Ansatz verkürzt die Zeit, die zum Bau von Prototypen benötigt wird, erheblich.

CodeLLM und AppLLM

Zwei zusätzliche Instruments unterstützen unterschiedliche Benutzertypen.

CodeLLM konzentriert sich auf Entwickler, die traditionelle Codierungsworkflows beschleunigen möchten. Es bietet Vorschläge zur automatischen Vervollständigung, Debugging-Hilfe und Projektgerüste.

AppLLMhingegen ist für technisch nicht versierte Benutzer konzipiert. Es ermöglicht Benutzern, Anwendungen direkt aus Eingabeaufforderungen zu generieren, ohne Code schreiben zu müssen.

Zusammen bilden diese Instruments eine Entwicklungsumgebung, in der sowohl erfahrene Ingenieure als auch Anfänger mit der Erstellung von Software program experimentieren können.

Vibe-Codierung verstehen

Das Konzept der Vibe-Coding-KI hat in letzter Zeit an Bedeutung gewonnen. Die Idee ist einfach: Anstatt wie ein Programmierer zu denken, beschreiben Sie das gewünschte Ergebnis und das System übernimmt die technische Umsetzung.

In der traditionellen Entwicklung umfasst die Erstellung einer Anwendung normalerweise mehrere Phasen:

• Planungsarchitektur
• Entwerfen von Datenbanken
• Backend-Logik schreiben
• Erstellen von Frontend-Schnittstellen

Mit Vibe Coding werden diese Schritte automatisiert.

Sie beginnen mit einer Eingabeaufforderung, in der die Produktidee beschrieben wird. Das System interpretiert dann diese Eingabeaufforderung und generiert automatisch die erforderlichen Komponenten.

Dies macht Entwickler zwar nicht völlig überflüssig, reduziert aber die Zeit, die für die Erstellung funktionierender Prototypen erforderlich ist, drastisch.

Praxisnaher Take a look at: Erstellen einer App anhand einer Eingabeaufforderung

Um den Workflow zu testen, habe ich versucht, eine einfache cell Anwendung mit Anweisungen in natürlicher Sprache zu erstellen.

In der Eingabeaufforderung wurde eine App beschrieben, die je nach Stimmung des Benutzers Rezepte, Musikwiedergabelisten und Einkaufslisten vorschlägt.

Anstatt sofort Code zu generieren, stellte das System einige klärende Fragen:

• Sollte die App Benutzereinstellungen speichern?
• Wie viele Stimmungskategorien sollte es geben?
• Sollten Playlists auf externe Plattformen verlinken?

Dieser Schritt struggle überraschend hilfreich, da er die Artwork von Fragen widerspiegelte, die ein menschlicher Entwickler während der Projektplanung stellen könnte.

Nachdem er diese Particulars gesammelt hatte, erstellte der Agent einen Entwicklungsplan und begann mit der Erstellung der Anwendung.

Innerhalb weniger Minuten erstellte das System einen funktionierenden Prototyp mit Schnittstellenelementen, Datenbanklogik und interaktiven Funktionen.

Preise und Wert

Ein Aspekt, der hervorsticht, ist die Preisstruktur.

Für viele KI-Instruments sind separate Abonnements erforderlich, die sich schnell summieren können. Codierungsassistenten, Recherchetools, Automatisierungssoftware und LLM-Zugriff kosten zusammen oft mehr als 100 US-Greenback professional Monat.

Diese Plattform bündelt viele dieser Funktionen in einem einzigen Abonnement, das etwa 10 bis 20 US-Greenback professional Monat kostet.

Hier ein einfacher Vergleich:

Besonderheit	Traditionelle KI-Instruments	Abacus KI
Chat-KI	Separate Abonnement	Im Lieferumfang enthalten
Codegenerierung	Separates Werkzeug	Im Lieferumfang enthalten
KI-Workflows	Separate Plattform	Im Lieferumfang enthalten
App-Entwicklung	Mehrere Werkzeuge	Integriert
Monatliche Kosten	80–200 $+	10 $

Wer sollte Abacus AI verwenden?

Entwickler und Startups

Für Entwickler ist die Plattform besonders nützlich für:

• Fast Prototyping
• Startup-Ideen testen
• schnelle Generierung von MVPs

Anstatt Wochen damit zu verbringen, die Infrastruktur aufzubauen, können sich die Groups auf die Validierung von Produktkonzepten konzentrieren.

Nicht-technische Bauherren

Interessanterweise könnte die Plattform für technisch nicht versierte Entwickler sogar noch wertvoller sein.

Unternehmer, Vermarkter und Entwickler können mit Anwendungsideen experimentieren, ohne vorher Programmiersprachen erlernen zu müssen.

Dies senkt die Eintrittsbarriere für die Softwareentwicklung erheblich.

Endgültiges Urteil: Kann Abacus AI mehr als 10 Instruments ersetzen?

Abacus KI stellt einen interessanten Wandel in der Entwicklung von KI-Softwareplattformen dar. Anstatt sich auf eine einzige Fähigkeit zu konzentrieren, versucht die Plattform, viele KI-Instruments in ein einheitliches Ökosystem zu integrieren.

Sein stärkstes Merkmal – Vibe Coding durch DeepAgent – ​​zeigt, wie schnell sich die Softwareentwicklung verändert. Die Fähigkeit, Beschreibungen in natürlicher Sprache in funktionierende Anwendungen umzuwandeln, ist nicht mehr experimentell; Es wird für reale Anwendungsfälle praktisch.

Dennoch ersetzt die Plattform herkömmliche Entwicklungsworkflows noch nicht vollständig. Komplexe Systeme erfordern immer noch menschliches Fachwissen, Debugging und Architekturentscheidungen.

Aber als Werkzeug für schnelles Experimentieren, KI-gesteuerte Arbeitsabläufe und frühe Entwicklungsphasen ist Abacus AI wirklich überzeugend.

Quelle:

Sechzehn autonome KI-Agenten. Zwei Wochen ununterbrochene Ausführung. Quick 100.000 Zeilen Rust-Code. Das battle es, was Anthropic brauchte, um einen funktionierenden C-Compiler zu entwickeln, der in der Lage battle, große reale Projekte wie den Linux-Kernel zu kompilieren. Hier gibt es jedoch einen Kicker. Das Projekt, das intern als Claudes „Agententeams“ bezeichnet wird, wurde nicht von einem menschlichen Ingenieurteam geschrieben. Es wurde von einem koordinierten Schwarm parallel arbeitender Claude-Agenten entwickelt, quick völlig ohne menschliches Zutun.

Aber seien Sie sich dessen bewusst: Dies battle keine automatische Vervollständigung bei Steroiden oder ein Chatbot, der zufällige Funktionen zusammenfügt. Die Claude-Agenten arbeiteten wie ein echtes Ingenieursteam, indem sie den Compiler in Module aufteilten, Verantwortlichkeiten zuwiesen, Komponenten schrieben, Testsuiten ausführten, Fehler behoben und kontinuierlich iterierten. Und das macht dies zu einem wichtigen Meilenstein im Zeitalter der KI-Entwicklung (Lernen Sie KI kostenlos). Was genau passiert ist und wie wichtig es ist, wollen wir in diesem Artikel untersuchen.

TL;DR

Sehen Sie sich stattdessen dieses Video an:

Was Anthropic gebaut hat

Im Kern zielte das Projekt von Anthropic darauf ab, einen vollständigen C-Compiler von Grund auf zu erstellen, aber, *warten Sie*, nur KI-Agenten zu verwenden. Dies battle kein Spielzeugdolmetscher oder eine Unterrichtsdemo. Dies battle ein echter Compiler, der Arbeitslasten auf Produktionsebene bewältigen konnte. Der Claude C Compiler wurde in Rust geschrieben und entwickelt, um C-Programme in ausführbaren Maschinencode auf wichtigen Architekturen wie x86-64 und ARM zu übersetzen.

Und dies wurde nicht an einfachen „Hey World“-Programmen getestet. Es wurde hart gedrängt. Der Compiler bewältigte erfolgreich große, komplexe Codebasen wie den Linux-Kernel und andere weit verbreitete Open-Supply-Projekte. Es hat auch einen erheblichen Teil der Folter-Testsuite von GCC bestanden, bei der es sich um eine brutale Sammlung von Randfällen handelt, die darauf ausgelegt sind, C-Compiler zu zerstören. Das macht diese Leistung so beeindruckend. Etwas zu bauen, das funktioniert, ist eine Sache. Eine andere Sache ist es, etwas zu entwickeln, das die von professionellen Compiler-Ingenieuren durchgeführten Stresstests übersteht.

Wie anthropisch es geschafft hat

Wie bringt man KI-Agenten dazu, etwas so Komplexes wie einen C-Compiler zu erstellen?

Der Schlüssel lag darin, sich nicht darauf zu verlassen, dass ein einzelnes Modell in einer Schleife läuft. Stattdessen setzten sie ein Staff von 16 parallel arbeitenden Claude-Agenten ein. Stellen Sie sich das so vor, als würden Sie ein kleines Ingenieurteam gründen, mit dem Unterschied, dass jeder Ingenieur eine KI-Instanz ist. Jeder Agent erhielt strukturierte Aufgaben, klare Ziele und Zugriff auf die gemeinsame Codebasis. Diese Agenten koordinierten dann hochspezifischen Code, um einen funktionierenden, erfolgreichen C-Compiler zu erstellen.

Die Orchestrierung battle eine weitere Säule. Zu diesem Zweck baute Anthropic ein System rund um die Agenten auf – eine kontrollierte Umgebung, in der sie Code schreiben, Exams ausführen, Fehler sehen, Probleme beheben und iterieren konnten. Wenn additionally etwas kaputt ging, machten die Agenten nicht Halt. Stattdessen wurde ein Debugging durchgeführt. Als die Exams fehlschlugen, überarbeiteten sie. Diese kontinuierliche Rückkopplungsschleife fungierte wie ein eingebautes Qualitätskontrollsystem.

Parallelität hat auch einen großen Unterschied gemacht. Während ein Agent an der Analyse der Logik arbeitete, konnte ein anderer die Codegenerierung übernehmen und wieder andere konzentrierten sich auf die Optimierung oder Fehlerbehebung. Anstelle eines linearen Fortschritts erfolgte die Entwicklung gleichzeitig an mehreren Fronten, was den Prozess erheblich beschleunigte.

Das battle keine Zauberei. Es battle strukturierte Autonomie.

Warum das eine große Sache ist

Compiler bilden die Grundlage der Datenverarbeitung. Jede von Ihnen verwendete App, jedes Betriebssystem, jeder Backend-Dienst durchläuft irgendwann einen Compiler. Der Aufbau eines solchen Programs gilt als ernsthafte systemtechnische Arbeit, eine Aufgabe für Entwickler mit den höchsten Fähigkeiten. Es erfordert ein tiefes Verständnis des Sprachdesigns, der Speicherverwaltung, Optimierungsstrategien, Architekturunterschiede und unzähliger Randfälle.

Wenn additionally KI-Agenten innerhalb von Wochen einen funktionierenden C-Compiler erstellen, signalisiert das einen gewaltigen Wandel.

Bis vor kurzem waren KI-Codierungstools (Schauen Sie sich hier die Prime 10 an) waren Assistenten. Bei max halfen sie Entwicklern beim Schreiben von Funktionen, schlugen Refaktoren vor oder generierten Boilerplates. Aber dieses Projekt ist der wahre Beweis dafür, dass KI mehrstufige, hochkomplexe Engineering-Aufgaben mit strukturierter Iteration und Exams bewältigen kann.

Wenn man darüber nachdenkt, kann dies die Softwareentwicklung, wie wir sie kennen, verändern.

Anstatt zu fragen: „Kann KI mir beim Schreiben dieser Funktion helfen?“ Die neue Frage lautet: „Kann KI einen gesamten Systemaufbau koordinieren und ausführen?“ Und wenn Compiler möglich sind, erstrecken sich die Möglichkeiten jetzt auf Datenbanken. Betriebssystemeund sogar umfassende Unternehmenstools.

Was es (noch) nicht kann

So beeindruckend das auch ist, der Claude C Compiler wird GCC oder Clang in absehbarer Zeit nicht ersetzen. Warum?

Zunächst einmal handelt es sich nicht um einen vollständig ausgereiften Compiler für die Produktion. Obwohl es den Linux-Kernel erfolgreich kompiliert und viele Belastungstests bestanden hat, unterstützt es noch nicht jeden Randfall oder jede Architekturvariante, die jahrzehntealte Compiler verarbeiten. Einige Low-Degree-Funktionen, wie z. B. bestimmte ältere x86-Verhaltensweisen, sind immer noch eingeschränkt. Auch für Teile der Toolchain, etwa für den Zusammenbau und die Verknüpfung, greift es auf vorhandene Instruments zurück.

Leistungsoptimierung ist ein anderer Bereich. Etablierte Compiler wurden jahrelang oder sogar jahrzehntelang verfeinert. Damit quetschen sie jedes Quäntchen Effizienz heraus. Der von Claude erstellte Compiler funktioniert, ist jedoch nicht unbedingt auf dieser Ebene optimiert.

Aber das ist okay.

Bei Anthropics Check geht es nicht um Perfektion. Es ging darum zu prüfen, ob das überhaupt möglich ist. Was wir hier sehen, sind autonome Systeme im Frühstadium, die bereits tiefgreifende technische Infrastrukturaufgaben bewältigen. Wenn es sich um Model eins handelt, können wir uns nur vorstellen, was Model fünf leisten kann.

Und hier wird es interessant.

Was kommt als nächstes?

In seinen Schlussbemerkungen innerhalb der WeblogNicholas Carlini, der Autor des Experiments und Forscher im Safeguards-Staff von Anthropic, teilt mit, dass das Experiment und seine Ergebnisse ihn zwar begeistern, ihm aber auch ein „Unwohlsein“ bereiten. Er hebt hervor, dass der Einsatz von KI für die Entwicklung bisher einem gemeinsamen Verfahren folgte: Ein Benutzer definiert eine Aufgabe, ein LLM erledigt sie und kehrt zurück, um eine Antwort zu erhalten.

Die völlig autonome Entwicklung durch die Claude-Agenten ändert das.

Stellen Sie sich das so vor – die wahre Geschichte hier ist nicht nur, dass die KI einen Compiler gebaut hat. Es geht darum, dass KI ein komplexes, langfristiges technisches Projekt mit Struktur, Iteration und Koordination verwaltet hat. Und das Ergebnis battle ein solider, funktionierender C-Compiler.

Heute ist es ein C-Compiler. Morgen könnten es ganze Backend-Systeme, verteilte Infrastrukturen, Simulations-Engines oder domänenspezifische Sprachen sein. Sobald Sie beweisen, dass Agenten ohne ständige menschliche Aufsicht zusammenarbeiten, sich selbst testen, Fehler beheben und weiterarbeiten können, erweitert sich der Anwendungsbereich schnell, und ich wage es zu sagen, ins Unendliche.

Carlini weist hier auf eine echte Bedrohung hin. Er sagt, dass es „leicht zu sehen ist, dass Exams bestanden werden, und davon auszugehen, dass die Arbeit erledigt ist“, wenn solche autonomen Systeme im Einsatz sind. Dies ist jedoch selten der Fall, und in den meisten Fällen gibt es Schwachstellen in solchen Systemen, die von Menschen überprüft werden müssen, bevor ein solches Programm zum Leben erweckt wird.

Während das Experiment additionally einen völlig neuen Horizont an Möglichkeiten aufzeigt, müssen wir sorgfältig überlegen, wie wir es in der kommenden Zeit in die Praxis umsetzen.

Abschluss

Für Entwickler muss ich Folgendes sagen: Bitte betrachten Sie diese Entwicklung nicht als „Sport Over“. Es bedeutet einfach, dass sich Ihre Rolle als Entwickler jetzt weiterentwickelt. Anstatt jede Zeile zu schreiben, können Sie zunehmend das System entwerfen, Einschränkungen definieren, Bewertungssysteme erstellen und Agententeams beaufsichtigen. Noch wichtiger ist, dass Sie solche Systeme auf jeden Fall auf Schwachstellen überprüfen müssen. Der von seinen Agenten erstellte Claude-C-Compiler zeigt uns eine Vorschau auf diese Zukunft.

KI hilft nicht mehr nur beim Schreiben von Code. Es beginnt mit dem Aufbau von Systemen. Und das ist eine ganz andere Liga.

Wenn Sie sich in letzter Zeit mit der Entwicklung von KI beschäftigen, sind Sie möglicherweise auf den Begriff „Agenten-Frameworks.‘ Heute werden wir über einen von ihnen sprechen, die Strands Brokers. Dabei handelt es sich um ein Instrument, das die Artwork und Weise verändert, wie Entwickler intelligente Systeme erstellen. Aber wenn Sie ein Anfänger sind, brauchen Sie sich keine Sorgen zu machen. Wir werden Sie in diesem Artikel auf einfache Weise durch alles führen.

Was sind Strands-Agenten?

Betrachten Sie Strands Brokers als den integrierten Betrieb des Gehirns und Körpers Ihrer KI. Im Gegensatz zu herkömmlichen Chatbots, die nur auf Ihre Eingaben reagieren, können diese Agenten verschiedene Aktionen ausführen. Sie können Informationen extrahieren, Lösungen finden, Werkzeuge bedienen und mehrere Aktionen verknüpfen, um schwierige Aufgaben zu erledigen.

Strands ist ein innovatives Modell, das von betrieben wird LangChaindas die gesamte Bandbreite an Funktionalitäten abdeckt, die solch komplexe Agenten mit sich bringen. Die Highlights von Strands sind seine Modularität; Anstatt lange Zeilen von Standardcode wiederholt zu programmieren, kann man eine kreative Methode nutzen, um vorgefertigte Teile wie LEGO-Blöcke miteinander zu verbinden, um die gewünschten KI-Systeme gekonnt aufzubauen.

Hauptmerkmale von Strands Brokers

Mit Strands können Sie ganz einfach Agenten erstellen und verfügen über sehr leistungsstarke Funktionen:

• Instrument-Integration: Ihr Agent stellt problemlos eine Verbindung zu APIs, Datenbanken, Suchmaschinen und benutzerdefinierten Funktionen her.
• Speicherverwaltung: Das System speichert alle Gespräche und behält den Kontext über mehrere Benutzerinteraktionen hinweg bei.
• Kettenorchestrierung: Der Workflow vereint verschiedene Vorgänge in einem nahtlosen Prozess.
• Fehlerbehandlung: Das System wiederholt fehlgeschlagene Aktionen automatisch und verwaltet das Failover reibungslos.
• Flexibilität: Es ist mit mehr als einem LLM-Anbieter kompatibel, beispielsweise OpenAI, Anthropic und Open-Supply-Modellen.
• Skalierbarkeit: Erstellen Sie einfach einfache Prototypen oder komplexe Systeme, die zur Produktion bereit sind.

Das Framework nimmt Ihnen die harte Arbeit ab, sodass Sie Ihre Zeit in die Entwicklung von Funktionen investieren können, anstatt sich mit der Infrastruktur herumschlagen zu müssen.

Warum Strands Brokers verwenden?

Künstliche Intelligenz ist in jeder Branche zu einem entscheidenden Aktivposten geworden. KI-Systeme, die nicht nur antworten, sondern auch dabei helfen, komplexe Entscheidungen zu treffen, sind die neuen Requirements auf dem Markt. Strands ist eine KI-Plattform, die diese Leistung ohne die übliche Komplexität bietet. Ob ein Kundenservice ohne Bot, der den Bestellstatus prüft, oder ein Forschungsassistent, der Daten aus mehreren Quellen bezieht, Strands würde in beiden Fällen die Architektur bereitstellen. Die Lernkurve verläuft reibungslos; Die Fähigkeiten sind jedoch enorm.

Komponenten von Strands Brokers

Lassen Sie uns zunächst die Grundkonzepte erklären, bevor wir zum praktischen Teil kommen. Ein typischer Agent in Strands besteht aus drei Hauptteilen:

• Sprachmodell: Der Verstand der KI, der Anfragen interpretiert und eine Vorgehensweise auswählt
• Werkzeuge: Verschiedene Funktionen, die Ihr Agent ausführen kann (z. B. Suchen, Berechnen oder Interagieren mit Datenbanken)
• Erinnerung: Die Artwork und Weise, wie der Agent den Kontext des Gesprächs und früherer Interaktionen festhält

Darüber hinaus verwendet Strands „Ketten“, eine Artwork von Operation, die vorab festgelegt ist, wenn sie in einer bestimmten Reihenfolge ausgeführt wird. Eine Kette kann so beschaffen sein, dass sie zunächst nach Informationen sucht, diese dann zusammenfasst und schließlich die Ausgabe formatiert präsentiert.

Erste Schritte mit Strands Agent

Installieren Sie zunächst Python Model 3.8 oder eine höhere Model auf Ihrem Pc. Das Erstellen einer virtuellen Umgebung ist die beste Methode zum Verwalten von Abhängigkeiten mit diesem Framework. Es wird einfacher, als sie ohne zu verwalten. Der nächste Schritt besteht darin, einen API-Schlüssel von einer Firma zu erhalten, die ihn bereitstellt große Sprachmodelle (LLMs). OpenAI, Anthropic und Cohere sind die drei großen Unternehmen, die für akademische Zwecke immer noch freien Zugang zu ihren Produkten gewähren.

Praktische Aufgabe 1: Aufbau eines Forschungsassistenten-Agenten

Wir werden einen Agenten entwickeln, der das Web durchsuchen und eine Zusammenfassung der Ergebnisse bereitstellen kann. Diese praktische Aufgabe führt Sie in die Grundlagen der Agentenentwicklung ein.

Schritt 1: Abhängigkeiten installieren

Starten Sie Ihr Terminal und erstellen Sie einen neuen Projektordner:

mkdir strands-research-agent 
cd strands-research-agent 
python -m venv venv 
supply venv/bin/activate  # On Home windows: venvScriptsactivate 
pip set up langchain langchain-openai langchain-community duckduckgo-search

Schritt 2: Erstellen Sie Ihre Agent-Datei

Erstellen Sie eine Datei namens „research_agent.py“ mit diesem Code:

from langchain.brokers import initialize_agent, Instrument 
from langchain.brokers import AgentType 
from langchain_openai import ChatOpenAI 
from langchain_community.instruments import DuckDuckGoSearchRun 
import os
# Set your OpenAI API key 
os.environ("OPENAI_API_KEY") = "your-api-key-here"
# Initialize the search instrument 
search = DuckDuckGoSearchRun()
# Outline instruments 
instruments = ( 
   Instrument( 
       identify="Net Search", 
       func=search.run, 
       description="Helpful for looking the web for present info." 
   ) 
) 
# Initialize the language mannequin 
llm = ChatOpenAI(temperature=0.7, mannequin="gpt-4o-mini")
# Create the agent 
agent = initialize_agent( 
   instruments=instruments, 
   llm=llm, 
   agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, 
   verbose=True 
)
# Check your agent 
if __name__ == "__main__": 
   question = "What are the newest developments in renewable power?" 
   response = agent.run(question) 
   print("nnFinal Reply:") 
   print(response) 

Schritt 3: Ausführen und testen

Speichern Sie zunächst die Datei und führen Sie sie dann mit dem Befehl python research_agent.py aus. Der Makler wird den gesamten Prozess durchlaufen und Ihnen einen schönen Überblick über seine Aktivitäten geben. Der Parameter verbosity = True ermöglicht es Ihnen, die Argumentation des Agenten mitzuerleben, die gleichzeitig sehr interessant und informativ ist.

Schritt 4: Passen Sie Ihren Agenten an

Machen Sie weiter und nehmen Sie diese Änderungen vor, um einen besseren Einblick zu erhalten:

• Verwenden Sie verschiedene Fragen, um verschiedene Fälle zu testen
• Ändern Sie den Temperaturparameter (0 für konzentrierte, 1 für fantasievolle Antworten)
• Implementieren Sie die Fehlerbehandlung durch Attempt-Exception-Blöcke
• Ändern Sie die Beschreibung des Instruments und beobachten Sie, wie sich dies auf die Aktion des Agenten auswirkt

Probieren Sie dies aus, indem Sie die Parameterebenen ändern, und beobachten Sie verschiedene Ergebnisse.

Praktische Aufgabe 2: Agentenrechner mit Speicher

Jetzt werden wir etwas Komplexeres erstellen, einen Agenten, der nicht nur arithmetische Berechnungen durchführt, sondern sich auch an die vergangenen erinnert. Was wäre eine bessere Möglichkeit, die Kontexterhaltung über einige Interaktionen hinweg darzustellen?

Schritt 1: Set up der Bibliotheken

Ein Mathematikpaket sollte in Ihrem Setup enthalten sein:

pip set up numexpr

Schritt 2: Entwicklung des Rechneragenten

Es sollte eine neue Datei mit dem Namen „calculator_agent.py“ erstellt werden:

from langchain_openai import ChatOpenAI 

from langchain_community.chat_message_histories import ChatMessageHistory 

from langchain_core.messages import HumanMessage, AIMessage, SystemMessage 

import os
# Set your API key
os.environ("OPENAI_API_KEY") = "api-key-here"
# Initialize the language mannequin
llm = ChatOpenAI(temperature=0, mannequin="gpt-4o-mini")
# Initialize chat historical past
chat_history = ChatMessageHistory()
def calculator_agent(user_input):
"""Calculator agent with reminiscence"""
# Construct messages with historical past
messages = (
SystemMessage(content material="You're a useful calculator assistant. Carry out mathematical calculations and keep in mind earlier outcomes. When the person refers to 'that outcome' or 'the earlier reply', use the dialog historical past to know what they imply.")
)
# Add chat historical past
messages.lengthen(chat_history.messages)
# Add present enter
messages.append(HumanMessage(content material=user_input))
# Get response
response = llm.invoke(messages)
# Save to historical past
chat_history.add_user_message(user_input)
chat_history.add_ai_message(response.content material)
return response.content material
# Interactive loop
if __name__ == "__main__":
print("Calculator Agent Prepared! (Kind 'stop' to exit)")
print("Attempt asking issues like:")
print("- What's 25 instances 4?")
print("- Add 50 to that outcome")
print("- What was my first calculation?n")
whereas True:
user_input = enter("nYou: ")
if user_input.decrease() == 'stop':
print("Goodbye!")
break
response = calculator_agent(user_input)
print(f"nAgent: {response}")

Schritt 3: Testen Sie die Speicherfunktionalität

Der erste Schritt besteht darin, die Befehlszeile zu öffnen und den Befehl „pythonrechner_agent.py“ auszuführen. Dann testen Sie dieses Verfahren:

Frage: „Was ist 25 mal 4?“

Nächste Frage: „Füge 50 zu diesem Ergebnis hinzu.“

Letzte Frage: „Was conflict meine erste Berechnung?“

Der Agent verfolgt vergangene Berechnungen und gibt Ihnen Zugriff darauf. Das ist der wunderbare Reminiscence-Effekt in seiner stärksten Type.

Schritt 4: Verstehen Sie die Komponenten

Der ConversationBufferMemory speichert alle Dialoge der vorherigen Konversation. Wenn Sie „dieses Ergebnis“ sagen, erinnert sich der Agent an Ihre Scenario und versteht sie. Das sind natürliche und menschenähnliche Interaktionen. Es können auch andere Speichertypen ausprobiert werden.

• KonversationZusammenfassungSpeicher: Bietet eine fortlaufende Zusammenfassung für längere Diskussionen
• ConversationBufferWindowMemory: Erinnert sich nur an die letzten N Interaktionen
• VectorStoreMemory: Speichert Interaktionen in einer durchsuchbaren Vektordatenbank

Für jeden Typ gibt es je nach Ihren Anforderungen eine eigene Anwendung.

Anwendungen aus der Praxis

Die gleichen Grundkonzepte, die den einfachen Agenten von heute zugrunde liegen, treiben auch die anspruchsvollen Agenten der Zukunft an. Hier sind einige Anwendungen, für die wir diese Agenten verwenden können, die ähnliche Strukturen implementieren:

• Bots für den Kundensupport, die den Standing von Bestellungen und Rücksendungen überprüfen
• KI-Helfer, die sich um Kalender, E-Mails und Buchungen kümmern
• Instruments für die Recherche, die Daten aus verschiedenen Kanälen sammeln
• Finanzberater, die sich die Marktstatistiken und die Efficiency der Portfolios ansehen
• Maschinen zur Inhaltserstellung, die nach Themen suchen, Artikel schreiben und Korrektur lesen

Betrachten Sie es als eine Weiterentwicklung unseres Forschungsagent bis hin zur Erstellung vollständiger Berichte oder einer Weiterentwicklung des Rechneragenten bis hin zur Durchführung von Finanzplanungen mit Echtzeitdaten über APIs.

Abschluss

Strands-Agenten stellen einen Wendepunkt in der Entwicklung der KI dar, da sie über eine Reihe fortschrittlicher Eigenschaften verfügen, die es ihnen ermöglichen, in den schwierigsten Fällen als menschliche Assistenten zu fungieren. Die Ära der Roboter, die nur sprechen, ist vorbei; Systeme handeln jetzt, erinnern sich und denken sogar.

Die beiden Agenten, die wir heute entwickelt haben, sind die Bausteine. Sie verstehen die Struktur, sehen den Arbeitscode und erleben den Entwicklungsworkflow. Jetzt bauen Sie einfach weiter, probieren Sie weiterhin neue Dinge aus und genießen Sie vor allem die Zeit dabei. Die Zukunft der KI entsteht gerade in diesem Second und Sie sind einer der Charaktere in dieser Handlung.

In AI-gesteuerten Anwendungen erfordern komplexe Aufgaben häufig in mehrere Unteraufgaben. Die genauen Unteraufgaben können jedoch in vielen realen Szenarien nicht vorbestimmt werden. In der automatisierten Codegenerierung hängen beispielsweise die Anzahl der zu ändernden Dateien und die erforderlichen Änderungen vollständig von der angegebenen Anforderung ab. Die traditionellen parallelisierten Workflows kämpfen unvorhersehbar und müssen im Voraus vordefinierte Aufgaben erfordern. Diese Steifigkeit begrenzt die Anpassungsfähigkeit von AI -Systemen.

Die Workflow-Agenten der Orchestrator-Arbeiter in Langgraph führen jedoch einen flexibleren und intelligenteren Ansatz, um diese Herausforderung anzugehen. Anstatt sich auf statische Aufgabendefinitionen zu verlassen, a Central Orchestrator LLM analysiert den Eingang dynamischbestimmt die erforderlichen Unteraufgaben und delegiert sie an spezialisierte Arbeiter -LLMs. Der Orchestrator sammelt und synthetisiert dann die Ausgänge und stellt ein zusammenhängendes Endergebnis sicher. Diese Gen AI Providers Aktivieren Sie Echtzeit-Entscheidungsfindung, adaptives Taskmanagement und höhere Genauigkeit, um sicherzustellen, dass komplexe Workflows mit intelligenterer Beweglichkeit und Präzision behandelt werden.

In diesem Sinne tauchen wir in das ein, worum es bei dem Workflow-Agenten von Orchestrator-Workflows in Langgraph geht.

Innerhalb von Langgraphs Orchestrator-Staff Agent: Smarter Activity Distribution

Die Orchestrator-Mitarbeiter Workflow Agent in Langgraph ist für dynamische Aufgabendelegation ausgelegt. In diesem Setup analysiert ein zentraler Orchestrator -LLM die Eingabe, unterteilt ihn in kleinere Unteraufgaben und weist sie spezialisierten Employee -LLMs zu. Sobald die Arbeiter -Agenten ihre Aufgaben erledigt haben, synthetiert der Orchestrator ihre Ausgaben zu einem zusammenhängenden Endergebnis.

Der Hauptvorteil der Verwendung des Workflow-Agenten für Orchestrator-Mitarbeiter ist:

• Anpassungsaufgabenhandhabung: Unteraufgaben werden nicht vordefiniert, sondern dynamisch bestimmt, wodurch der Workflow hoch flexibel ist.
• Skalierbarkeit: Der Orchestrator kann mehrere Arbeiter nach Bedarf effizient verwalten und skalieren.
• Verbesserte Genauigkeit: Das System sorgt für präzisere und kontextbezogene Ergebnisse, indem sie Aufgaben dynamisch an spezialisierte Arbeitnehmer delegieren.
• Optimierte Effizienz: Aufgaben werden effizient verteilt, wodurch Engpässe verhindern und nach Möglichkeit parallele Ausführung ermöglichen.

Schauen wir uns kein Beispiel an. Erstellen wir einen Orchestrator-Arbeiter-Workflow-Agenten, der die Eingabe des Benutzers als Weblog-Thema verwendet, z. B. ein Weblog auf Agentenlappen. ““ Der Orchestrator analysiert das Thema und plant verschiedene Abschnitte des Blogs, einschließlich Einführung, Konzepte und Definitionen, aktuelle Anwendungen, technologischen Fortschritte, Herausforderungen und Einschränkungen und mehr.

Importieren der erforderlichen Bibliotheken.

Jetzt müssen wir die LLM laden. Für diesen Weblog werden wir das QWEN2.5-32B-Modell von COQ verwenden.

Lassen Sie uns nun eine pydantische Klasse erstellen, um sicherzustellen, dass die LLM strukturierte Ausgabe erzeugt. In der pydantischen Klasse stellen wir sicher, dass das LLM eine Liste von Abschnitten erstellt, die jeweils den Abschnittsnamen und die Beschreibung enthalten. Diese Abschnitte werden später den Arbeitnehmern gegeben, damit sie parallel an jedem Abschnitt arbeiten können.

Jetzt müssen wir die Zustandsklassen erstellen, die einen Graph -Standing mit gemeinsam genutzten Variablen darstellen. Wir werden zwei staatliche Klassen definieren: einen für den gesamten Graph State und einen für den Arbeitnehmerstaat.

Jetzt können wir die Knoten definieren – den Orchestratorknoten, den Arbeiterknoten, den Synthesizerknoten und den bedingten Knoten.

Orchestratorknoten: Dieser Knoten ist für die Generierung der Abschnitte des Blogs verantwortlich.

Arbeiterknoten: Dieser Knoten wird von den Arbeitnehmern verwendet, um Inhalte für die verschiedenen Abschnitte zu generieren

Synthesizerknoten: Dieser Knoten nimmt die Ausgabe jedes Arbeiters an und kombiniert ihn, um die endgültige Ausgabe zu erzeugen.

Bedingter Knoten, um Arbeiter zuzuweisen: Dies ist der bedingte Knoten, der für die Zuweisung der verschiedenen Abschnitte des Blogs verschiedenen Arbeitnehmern verantwortlich ist.

Lassen Sie uns nun das Diagramm erstellen.

Wenn Sie das Diagramm mit einem Thema aufrufen, unterteilt der Orchestratorknoten es in Abschnitte, der bedingte Knoten bewertet die Anzahl der Abschnitte und weist die Arbeitnehmer dynamisch zu – beispielsweise werden zwei Arbeiter erstellt. Jeder Arbeiterknoten generiert dann Inhalte für seinen zugewiesenen Abschnitt parallel. Schließlich kombiniert der Synthesizer -Knoten die Ausgänge in einem zusammenhängenden Weblog und gewährleistet einen effizienten und organisierten Inhaltserstellungsprozess.

Es gibt auch andere Anwendungsfälle, die wir mit dem Orchestrator-Workflow-Agenten lösen können. Einige von ihnen sind unten aufgeführt:

• Automatisierte Testfallgenerierung -Testen der Einheiten durch automatische Generierung von Code-basierten Testfällen.
• Codequalitätssicherung – Gewährleistung einer konsistenten Codestandards durch Integration Automatisierte Testgenerierung in CI/CD -Pipelines.
• Softwaredokumentation – Generieren von UML- und Sequenzdiagrammen für eine bessere Projektdokumentation und Verständnis.
• Legacy Code Refactoring -Unterstützung bei der Modernisierung und Prüfung von Legacy-Anwendungen durch automatische generierende Testabdeckung.
• Beschleunigung von Entwicklungszyklen – Reduzierung der manuellen Anstrengungen beim Schreiben von Checks, sodass Entwickler sich auf die Entwicklung von Merkmalen konzentrieren können.

Der Workflow -Agent von Orchestrator Staff erhöht nicht nur die Effizienz und Genauigkeit, sondern verbessert auch die Wartbarkeit und die Zusammenarbeit von Code und Zusammenarbeit in den Groups.

Schließungsleitungen

Abschließend stellt der Orchestrator-Workflow-Agent in Langgraph einen zukunftsorientierten und skalierbaren Ansatz zur Behandlung komplexer, unvorhersehbarer Aufgaben dar. Durch die Verwendung eines zentralen Orchestrators zur Analyse von Eingängen und dynamisch in Unteraufgaben weist das System jede Aufgabe spezialisierten Arbeiterknoten, die parallel funktionieren, effektiv zu.

Ein Synthesizerknoten integriert dann diese Ausgänge nahtlos und stellt ein zusammenhängendes Endergebnis sicher. Die Verwendung staatlicher Klassen für die Verwaltung gemeinsamer Variablen und eines bedingten Knotens zur dynamischen Zuordnung von Arbeitnehmern sorgt für eine optimale Skalierbarkeit und Anpassungsfähigkeit.

Diese versatile Architektur vergrößert die Effizienz und Genauigkeit nicht nur, sondern passt sich auch clever an unterschiedliche Arbeitsbelastungen an, indem Ressourcen zugewiesen werden, an denen sie am meisten benötigt werden. Kurz gesagt, sein vielseitiges Design ebnet den Weg für eine verbesserte Automatisierung in verschiedenen Anwendungen und fördert letztendlich eine stärkere Zusammenarbeit und beschleunigte Entwicklungszyklen in der heutigen dynamischen technologischen Landschaft.

Einführung

Herzlichen Glückwunsch! Sie führen ein erfolgreiches Unternehmen. Über Ihre Webseiten, Social-Media-Kampagnen, Webinare, Konferenzen, kostenlose Ressourcen und andere Quellen sammeln Sie täglich über 5000 E-Mail-IDs. Der nächste logische Schritt besteht darin, ihnen eine E-Mail basierend auf der Quelle und dem Nutzerverhalten dieser Benutzer zu senden, mit dem Ziel, sie in zahlende Kunden umzuwandeln. Mit generativen KI-AgentenMarketingmanager können die Bandbreite des Groups für kreative Aufgaben reduzieren, indem sie autonome E-Mail-Systeme aufbauen, ohne sich Gedanken über das Volumen der zu versendenden E-Mails machen zu müssen. Dieser Artikel zeigt Ihnen, wie Sie GenAI-Agenten in Ihrem Unternehmen implementieren können, um das E-Mail-Advertising zu automatisieren.

Überblick

• Verstehen Sie, wie herkömmliche E-Mail-Marketingsysteme funktionieren und welche Herausforderungen damit verbunden sind.
• Erfahren Sie mehr über die verschiedenen GenAI-Agenten, die Sie für die reibungslose Durchführung autonomen E-Mail-Marketings erstellen werden.
• Verstehen Sie die Bedeutung menschlicher Eingriffe und Rückmeldungen beim Testen Ihres Agentensystems.

Traditionelles E-Mail-System

Lassen Sie uns zunächst das traditionelle E-Mail-System verstehen. Stellen Sie sich vor, Sie verfügen über eine umfangreiche Internetpräsenz, die die Web site Ihres Unternehmens mit mehreren Webseiten, Blogs, kostenlosen Downloads usw. umfasst. Und Sie sind ständig bestrebt, Ihre Onlinepräsenz mit Webinaren, Onlinekonferenzen und Zugang zu kostenlosen E-Books und Produkttests zu erweitern. All dies führt zu einer riesigen Sammlung von E-Mail-IDs. Ein generisches traditionelles Marketingsystem umfasst:

• Führen Sie eine ordnungsgemäße Aufzeichnung der Quelle der E-Mail-ID (Anmeldungen, Webinare, Downloads) und verfolgen Sie deren Verhalten (welche Webseiten sie besucht haben, welche Ressourcen sie heruntergeladen haben, an welchen Webinaren sie teilgenommen haben usw.).
• Basierend auf dem oben genannten Punkt segmentiert das Marketingteam die Kunden anhand ähnlicher Eigenschaften und sendet an jedes Phase angepasste E-Mails.
• Abhängig von der Reaktion auf die E-Mail (ob eine Particular person die E-Mail geöffnet hat, die nächste E-Mail gesendet wird usw.) wird nun entweder eine Erinnerungs-E-Mail oder eine angepasste E-Mail (basierend auf der Aktivität bei der ersten E-Mail) gesendet. Dieser Zyklus wird fortgesetzt, bis der Lead nicht mehr reagiert oder zu einem zahlenden Kunden wird. In diesem Schritt analysieren wir auch die Leistung der E-Mail anhand von Engagement-Metriken wie Klickrate, Öffnungsrate usw.

Klingt langweilig und überfüllt, nicht wahr? Aber mit Generative KIkönnen wir autonome Agentensysteme erstellen, die im Rahmen der von der Organisation festgelegten Regeln und Grenzen das Notwendige tun. Werfen wir einen kurzen Blick auf Agenten.

Was sind KI-Agenten?

So wie Sie ein Reisebüro damit beauftragen, die Planung Ihrer Reise zu delegieren, damit Sie mehr Zeit für produktivere/relevantere Dinge haben, sind KI-Agenten die modernen Instruments, mit denen Sie komplexe autonome Systeme zur Ausführung sich wiederholender oder sonstiger Aufgaben erstellen können.

Ein KI-Agent kann die Umgebung und die Umstände verstehen, mit denen er konfrontiert ist. Er kann ohne menschliches Eingreifen Entscheidungen auf Grundlage der Umgebung treffen und auf Grundlage dieser Entscheidungen Aufgaben ausführen.

Die kritische Aufgabe während Erstellen von Agentensystemen besteht nicht darin, die Agenten zu erstellen, sondern die Struktur des autonomen Agentensystems, die Anzahl der zu erstellenden Agenten usw. zu definieren. Wir werden dies verstehen, wenn wir uns damit befassen, wie man ein autonomes E-Mail-System aufbaut.

E-Mail-Advertising-Optimierung mit GenAI-Agenten

Sehen wir uns an, wie Sie Ihr Marketingteam umgestalten und seinen Arbeitsablauf effizienter gestalten können.

Hier sind die vier Schritte, die Sie befolgen können, um mithilfe generativer KI-Agenten eine automatisierte E-Mail-Marketingkampagne zu erstellen.

1. Planen des Agentensystems
2. Erstellen des Agentensystems
3. Leistungsbewertung mit menschlichem Eingreifen
4. Canary-Bereitstellung und Suggestions-Implementierung

Lassen Sie uns additionally die oben genannten Schritte nacheinander durchgehen.

Schritt 1: Planen des Agentensystems

Der allererste Schritt besteht darin, die Struktur für das Agentensystem aufzubauen. Die Struktur sollte hauptsächlich Folgendes umfassen:

1. Identifizieren der Aufgaben

Ein effizientes System sollte die richtige Anzahl von KI-Agenten wo kein Agent überlastet oder unterausgelastet ist. Die beste Methode, die Anzahl der Agenten zu bestimmen, besteht darin, die anfallenden Aufgaben und die Anzahl der Personen zu ermitteln, die zur Durchführung dieser Aufgaben erforderlich sind, um das Ziel auf herkömmliche Weise zu erreichen.

In unserem Fall müssen wir vier Aufgaben ausführen, wenn wir dem traditionellen E-Mail-Marketingsystem folgen:

1. Schreiben der E-Mail
2. Bearbeiten der E-Mail
3. Planung der Kampagne
4. Veröffentlichung/Versand der E-Mail-Kampagne

2. Festlegen der Anzahl der Agenten

Sobald wir die Aufgaben fertig haben, besteht der nächste Schritt darin, die Aufgaben dem Agenten zuzuweisen. Idealerweise sollte ein Agent eine Hauptaufgabe haben. Dies ist jedoch keine feste Regel; ein Agent kann auch mehrere kleine Aufgaben übernehmen. In unserem Fall beschränken wir uns jedoch auf eine Aufgabe für jeden Agenten. Daher erstellen wir vier Agenten:

1. Schriftsteller
2. Editor
3. Planer
4. Herausgeber

3. Gestaltung der Interaktivität zwischen Agenten

Der nächste Schritt besteht darin, die Interaktivität zwischen Agenten herzustellen. In unserem Fall sieht der Ablauf so aus: so was:

1. Der Author-Agent ruft Benutzerdetails für jede E-Mail-ID ab und schreibt mithilfe eines LLM eine E-Mail.
2. Der Editor-Agent übernimmt die E-Mail vom Author-Agent und bearbeitet sie entsprechend den festgelegten Richtlinien.
3. Basierend auf dem Betreff und dem Inhalt der bearbeiteten E-Mail plant der Planner-Agent die Kampagne und legt Anweisungen fest.
4. Der Writer-Agent sammelt die Anweisungen vom Planner-Agenten und die bearbeitete E-Mail vom Editor-Agenten und sendet die E-Mail gemäß den Anweisungen.

Sobald die drei oben genannten Punkte geklärt sind, besteht der nächste Schritt darin, das Agentensystem zu erstellen.

Schritt 2: Erstellen eines Agentensystems

In diesem Schritt konstruieren wir die vier Agenten, die wir in der Planungsphase entworfen haben:

1. Schriftsteller

Der Author ist der erste Agent in Ihrem autonomen System. Sobald eine E-Mail-ID zur Datenbank hinzugefügt wurde, überprüft der Author-Agent die Quelle und das aufgezeichnete Verhalten. Darauf basierend schreibt er dann eine E-Mail unter Verwendung des bevorzugten LLM, mit dem Sie sich verbunden haben. Der Author-Agent berücksichtigt auch die Regeln für Wörter, die Sie nicht verwenden dürfen, und andere relevante Parameter gemäß den Markenrichtlinien.

Beim Schreiben der E-Mail kann es auf vorherige E-Mails verweisen, die Sie mit dem gleichen Verhalten im herkömmlichen Setup gesendet haben, um Halluzinationen vorzubeugen und zu versuchen, die E-Mail zu verbessern, um die Chancen auf höhere Öffnungs- und Klickraten zu erhöhen.

Notiz: Da der Planer die erfassten Daten verwendet, müssen Sie sicherstellen, dass Ihre Datenerfassung korrekt ist. Andernfalls werden Sie Zeuge davon, wie Müll hereinkommt und Müll hinausgeht.

2. Herausgeber

Als nächstes kommt der Editor-Agent in Aktion. Der Editor-Agent überprüft die vom Author-Agent geschriebene E-Mail. Sie können den Editor bitten, die Grammatik der geschriebenen E-Mail zu überprüfen, ob sie mit dem Plan des Planner-Agenten übereinstimmt, ob unparlamentarische Wörter vorhanden sind usw.

Notiz: Der Redakteur muss Gründlichkeit und Effizienz in Einklang bringen. Zu viel Bearbeitung kann die Kampagne verzögern, während zu wenig Bearbeitung dazu führen kann, dass Fehler durchrutschen. Es ist entscheidend, sicherzustellen, dass die Regeln des Agenten intestine definiert sind.

3. Planer

Der Planer-Agent überprüft die bearbeitete E-Mail vom Editor-Agent. Er überprüft den E-Mail-Inhalt und die Betreffzeile und greift auch auf den Verlauf des Benutzers zu, um den richtigen Zeitpunkt für die Planung der E-Mail zu ermitteln.

Sobald die erste E-Mail an die neu angemeldete Particular person gesendet wurde, werden die E-Mail und ihre Leistung in einer vorab festgelegten Datenbank gespeichert. Der Planer-Agent kann dann Runde 2 der E-Mail für dieselbe Particular person planen.

4. Herausgeber

Der Writer-Agent veröffentlicht die Kampagne über die E-Mail-Software program des Unternehmens, basierend auf den Anweisungen des Planner-Agenten. Der Writer-Agent sammelt auch den Bericht über die Leistung der E-Mail und fügt ihn der Datenbank hinzu. Dieser wird dann vom Author-Agenten gesammelt, um zu bestimmen, wie die Folge-E-Mail aussehen soll.

Damit ist die Erstellung des Agenten abgeschlossen. Der nächste Schritt besteht darin, ihn intern anhand von Beispieldaten zu testen.

Schritt 3: Leistungsbewertung mit menschlichem Eingreifen

Sie können entweder synthetische Daten generieren oder einfach einige E-Mails generieren, indem Sie einige Beispiele unterschiedlichen Verhaltens auswählen.

Sobald die E-Mail aus den Beispieldaten generiert wurde, müssen der Marketingmanager und das Staff oder die betroffenen Personen in der Organisation die E-Mail lesen und prüfen. Dies muss mit großer Liebe zum Element erfolgen, da alle Änderungen am Agenten auf der Grundlage ihres Feedbacks vorgenommen werden müssen, bevor er in die Produktion überführt wird.

Basierend auf den Testergebnissen müssen wir zu Schritt 2 zurückkehren und die Agenten ändern, bis wir das gewünschte Ergebnis erhalten. Dieser Schritt ist absolut entscheidend und kann nicht vermieden werden, unabhängig davon, wie viele Iterationen erforderlich sind, um das bestmögliche Ergebnis zu erzielen.

Schritt 4: Canary-Bereitstellung und Suggestions-Implementierung

Sobald die internen Checks abgeschlossen sind, besteht der nächste Schritt in der Bereitstellung. Die beste Strategie hierfür ist die Canary-Bereitstellung, bei der wir die neue Model eines Instruments schrittweise veröffentlichen, um Störungen zu minimieren und Echtzeittests für eine Teilmenge von Benutzern zu ermöglichen.

Wenn Sie eine kleine Datenbank haben, können Sie die Agentensystem bis zu 20 % des Modells, und wenn Sie eine Datenbank mit Millionen haben, können Sie es sogar auf 1 % ausweiten. In dieser Part analysieren wir die Engagement-Metriken wie CTR, Öffnungsrate usw., um zu sehen, ob sie sich in diesem Satz verbessern. Wenn nicht, müssen Sie Ihr Agentensystem erneut ändern und sehen, ob sich seine Leistung verbessert.

Notiz: Selbst in diesem Stadium kann man das System nicht als autonom bezeichnen, da es weiterhin ständiges menschliches Eingreifen erfordert, um sicherzustellen, dass die Agenten sich basierend auf der Leistung der gesendeten E-Mails verbessern.

Sobald wir mit der Leistung des Beispielsatzes zufrieden sind, können wir die Teilmenge des Publikums, auf das das Modell angewendet wird, schrittweise erhöhen. Bei jeder Erhöhung der Teilmenge müssen wir ihre Leistung überprüfen und die Agenten entsprechend optimieren, bis wir die beste Leistung für unsere E-Mail-Kampagnen erzielen.

Am Ende dieser Übung verfügen wir über ein voll funktionsfähiges KI-Agentensystem für E-Mail-Advertising, das nicht nur E-Mails generiert, sondern auch die Leistung der E-Mails aufzeichnet. Diese Leistungsaufzeichnung wird vom Author-Agenten beim Schreiben der Folge-E-Mails als Suggestions berücksichtigt.

Abschluss

Die Optimierung der E-Mail-Marketingkampagnen Ihres Unternehmens mit GenAI-Agenten ermöglicht eine personalisierte, effiziente und skalierbare Kommunikation mit Ihrem Publikum. Durch die Implementierung eines autonomen Agentensystems optimieren Sie den Prozess der E-Mail-Erstellung und -Verteilung, verbessern die Kundenbindung und reduzieren gleichzeitig den manuellen Aufwand. Mit der richtigen Einrichtung, Leistungsüberwachung und iterativen Verbesserungen können Ihre KI-gestützten E-Mail-Kampagnen die Öffnungs- und Klickraten erheblich steigern, was zu höheren Konversionsraten und einem insgesamt höheren Geschäftserfolg führt.

Wenn Sie mehr über AI Brokers erfahren möchten, besuchen Sie unsere GenAI Pinnacle-Programm.

Häufig gestellte Fragen