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.

In diesem Tutorial erstellen wir von Grund auf einen fortschrittlichen Agenten für die Computernutzung, der mithilfe eines lokalen, offenen Modells virtuelle Aktionen begründen, planen und ausführen kann. Wir erstellen einen simulierten Miniatur-Desktop, statten ihn mit einer Software-Schnittstelle aus und entwerfen einen intelligenten Agenten, der seine Umgebung analysieren, über Aktionen wie Klicken oder Tippen entscheiden und diese Schritt für Schritt ausführen kann. Am Ende sehen wir, wie der Agent Ziele wie das Öffnen von E-Mails oder das Erstellen von Notizen interpretiert und demonstrieren so, wie ein lokales Sprachmodell interaktives Denken und Aufgabenausführung nachahmen kann. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

!pip set up -q transformers speed up sentencepiece nest_asyncio
import torch, asyncio, uuid
from transformers import pipeline
import nest_asyncio
nest_asyncio.apply()

Wir richten unsere Umgebung ein, indem wir wichtige Bibliotheken wie Transformers, Speed up und Nest Asyncio installieren, die es uns ermöglichen, lokale Modelle und asynchrone Aufgaben nahtlos in Colab auszuführen. Wir bereiten die Laufzeit so vor, dass die kommenden Komponenten unseres Agenten ohne externe Abhängigkeiten effizient arbeiten können. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class LocalLLM:
   def __init__(self, model_name="google/flan-t5-small", max_new_tokens=128):
       self.pipe = pipeline("text2text-generation", mannequin=model_name, system=0 if torch.cuda.is_available() else -1)
       self.max_new_tokens = max_new_tokens
   def generate(self, immediate: str) -> str:
       out = self.pipe(immediate, max_new_tokens=self.max_new_tokens, temperature=0.0)(0)("generated_text")
       return out.strip()


class VirtualComputer:
   def __init__(self):
       self.apps = {"browser": "https://instance.com", "notes": "", "mail": ("Welcome to CUA", "Bill #221", "Weekly Report")}
       self.focus = "browser"
       self.display screen = "Browser open at https://instance.comnSearch bar centered."
       self.action_log = ()
   def screenshot(self):
       return f"FOCUS:{self.focus}nSCREEN:n{self.display screen}nAPPS:{listing(self.apps.keys())}"
   def click on(self, goal:str):
       if goal in self.apps:
           self.focus = goal
           if goal=="browser":
               self.display screen = f"Browser tab: {self.apps('browser')}nAddress bar centered."
           elif goal=="notes":
               self.display screen = f"Notes AppnCurrent notes:n{self.apps('notes')}"
           elif goal=="mail":
               inbox = "n".be part of(f"- {s}" for s in self.apps('mail'))
               self.display screen = f"Mail App Inbox:n{inbox}n(Learn-only preview)"
       else:
           self.display screen += f"nClicked '{goal}'."
       self.action_log.append({"sort":"click on","goal":goal})
   def sort(self, textual content:str):
       if self.focus=="browser":
           self.apps("browser") = textual content
           self.display screen = f"Browser tab now at {textual content}nPage headline: Instance Area"
       elif self.focus=="notes":
           self.apps("notes") += ("n"+textual content)
           self.display screen = f"Notes AppnCurrent notes:n{self.apps('notes')}"
       else:
           self.display screen += f"nTyped '{textual content}' however no editable subject."
       self.action_log.append({"sort":"sort","textual content":textual content})

Wir definieren die Kernkomponenten, ein leichtes lokales Modell und einen virtuellen Pc. Wir verwenden Flan-T5 als unsere Argumentationsmaschine und erstellen einen simulierten Desktop, der Apps öffnen, Bildschirme anzeigen und auf Tipp- und Klickaktionen reagieren kann. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class ComputerTool:
   def __init__(self, pc:VirtualComputer):
       self.pc = pc
   def run(self, command:str, argument:str=""):
       if command=="click on":
           self.pc.click on(argument)
           return {"standing":"accomplished","end result":f"clicked {argument}"}
       if command=="sort":
           self.pc.sort(argument)
           return {"standing":"accomplished","end result":f"typed {argument}"}
       if command=="screenshot":
           snap = self.pc.screenshot()
           return {"standing":"accomplished","end result":snap}
       return {"standing":"error","end result":f"unknown command {command}"}

Wir stellen die ComputerTool-Schnittstelle vor, die als Kommunikationsbrücke zwischen der Argumentation des Agenten und dem virtuellen Desktop fungiert. Wir definieren Vorgänge auf hoher Ebene wie Klicken, Tippen und Screenshot, die es dem Agenten ermöglichen, auf strukturierte Weise mit der Umgebung zu interagieren. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class ComputerAgent:
   def __init__(self, llm:LocalLLM, software:ComputerTool, max_trajectory_budget:float=5.0):
       self.llm = llm
       self.software = software
       self.max_trajectory_budget = max_trajectory_budget
   async def run(self, messages):
       user_goal = messages(-1)("content material")
       steps_remaining = int(self.max_trajectory_budget)
       output_events = ()
       total_prompt_tokens = 0
       total_completion_tokens = 0
       whereas steps_remaining>0:
           display screen = self.software.pc.screenshot()
           immediate = (
               "You're a computer-use agent.n"
               f"Person objective: {user_goal}n"
               f"Present display screen:n{display screen}nn"
               "Assume step-by-step.n"
               "Reply with: ACTION <click on/sort/screenshot> ARG <goal or textual content> THEN <assistant message>.n"
           )
           thought = self.llm.generate(immediate)
           total_prompt_tokens += len(immediate.break up())
           total_completion_tokens += len(thought.break up())
           motion="screenshot"; arg=""; assistant_msg="Working..."
           for line in thought.splitlines():
               if line.strip().startswith("ACTION "):
                   after = line.break up("ACTION ",1)(1)
                   motion = after.break up()(0).strip()
               if "ARG " in line:
                   half = line.break up("ARG ",1)(1)
                   if " THEN " partially:
                       arg = half.break up(" THEN ")(0).strip()
                   else:
                       arg = half.strip()
               if "THEN " in line:
                   assistant_msg = line.break up("THEN ",1)(1).strip()
           output_events.append({"abstract":({"textual content":assistant_msg,"sort":"summary_text"}),"sort":"reasoning"})
           call_id = "call_"+uuid.uuid4().hex(:16)
           tool_res = self.software.run(motion, arg)
           output_events.append({"motion":{"sort":motion,"textual content":arg},"call_id":call_id,"standing":tool_res("standing"),"sort":"computer_call"})
           snap = self.software.pc.screenshot()
           output_events.append({"sort":"computer_call_output","call_id":call_id,"output":{"sort":"input_image","image_url":snap}})
           output_events.append({"sort":"message","position":"assistant","content material":({"sort":"output_text","textual content":assistant_msg})})
           if "completed" in assistant_msg.decrease() or "right here is" in assistant_msg.decrease():
               break
           steps_remaining -= 1
       utilization = {"prompt_tokens": total_prompt_tokens,"completion_tokens": total_completion_tokens,"total_tokens": total_prompt_tokens + total_completion_tokens,"response_cost": 0.0}
       yield {"output": output_events, "utilization": utilization}

Wir konstruieren den ComputerAgent, der als intelligenter Controller des Programs dient. Wir programmieren es so, dass es über Ziele nachdenkt, entscheidet, welche Maßnahmen ergriffen werden sollen, diese über die Software-Schnittstelle ausführt und jede Interaktion als Schritt im Entscheidungsprozess aufzeichnet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

async def main_demo():
   pc = VirtualComputer()
   software = ComputerTool(pc)
   llm = LocalLLM()
   agent = ComputerAgent(llm, software, max_trajectory_budget=4)
   messages=({"position":"consumer","content material":"Open mail, learn inbox topics, and summarize."})
   async for end in agent.run(messages):
       print("==== STREAM RESULT ====")
       for occasion in end result("output"):
           if occasion("sort")=="computer_call":
               a = occasion.get("motion",{})
               print(f"(TOOL CALL) {a.get('sort')} -> {a.get('textual content')} ({occasion.get('standing')})")
           if occasion("sort")=="computer_call_output":
               snap = occasion("output")("image_url")
               print("SCREEN AFTER ACTION:n", snap(:400),"...n")
           if occasion("sort")=="message":
               print("ASSISTANT:", occasion("content material")(0)("textual content"), "n")
       print("USAGE:", end result("utilization"))


loop = asyncio.get_event_loop()
loop.run_until_complete(main_demo())

Wir bringen alles zusammen, indem wir die Demo ausführen, bei der der Agent die Anfrage eines Benutzers interpretiert und Aufgaben auf dem virtuellen Pc ausführt. Wir beobachten, wie es Überlegungen anstellt, Befehle ausführt, den virtuellen Bildschirm aktualisiert und sein Ziel klar und Schritt für Schritt erreicht.

Zusammenfassend haben wir die Essenz eines computergestützten Agenten implementiert, der zu autonomem Denken und Interaktion fähig ist. Wir erleben, wie lokale Sprachmodelle wie Flan-T5 die Automatisierung auf Desktop-Ebene in einer sicheren, textbasierten Sandbox wirkungsvoll simulieren können. Dieses Projekt hilft uns, die Architektur hinter intelligenten Agenten zu verstehen, beispielsweise denen in Pc-Agenten, indem es das Denken in natürlicher Sprache mit der Steuerung virtueller Werkzeuge verbindet. Es schafft eine solide Grundlage für die Ausweitung dieser Fähigkeiten auf reale, multimodale und sichere Automatisierungssysteme.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.