CopilotKit veröffentlicht CLiF: Eine Continual-Learning-Plattform, die Agent-Traces und Nutzeraktionen in Skills, Evals und…

Einführung

Teams, die KI-Agents im großen Maßstab ausliefern, stoßen immer wieder auf dasselbe Muster. Selbst Agents, die auf Spitzmodellen wie Fable und Astra aufbauen, schaffen es kaum, komplexe End-to-End-Aufgaben innerhalb eines bestimmten Produkts konsistent genug auszuführen, um sie bereitzustellen. Deshalb arbeiten Teams mühsam Evals für die wichtigsten Workflows aus, oft hunderte oder tausende handgeschriebene Fälle, und verbessern den Agent dann Stück für Stück durch Prompt-Anpassungen, Harness-Fixes und Sonderfälle, bis er genug davon besteht, um live zu gehen.

Währenddessen führen die Nutzer des Produkts selbst genau diese Aufgaben täglich aus und wissen, welche Aktionen in welcher Reihenfolge erforderlich sind. CopilotKit, das Unternehmen hinter dem Open-Source-Framework CopilotKit und dem AG-UI-Protokoll, hat CLiFveröffentlicht, eine Plattform für kontinuierliches Lernen aus Full-Stack-Trajektorien, als Early Access. CLiF erfasst sicher, was der Agent tut und was Nutzer im Produkt tun, und wandelt diese Aufzeichnung in Skills, produktionsbasierte Evals und Fine-Tuning-Datensätze um, die alle zusammen mit den Roh-Trajektorien exportierbar sind.

CopilotKit ist Open Source, mit mehr als 38,000 Sternen auf GitHub.

TL;DR

• Agent-Tracing zeigt, wo ein Agent einen Fehler gemacht hat, während der korrekte Weg in dem liegt, was Nutzer im Produkt tun – was die meisten Stacks nie erfassen.
• CLiF, derzeit im Early Access, lernt aus Full-Stack-Trajektorien: dem Agent-Trace und den Aktionen des Nutzers im Produkt, sicher erfasst als eine Timeline über AG-UI.
• Eine vierstufige Schleife, aufbauend auf CopilotKits Automatic Learning, wandelt diese Full-Stack-Trajektorien in Skills, produktionsbasierte Evals, Fine-Tuning-Datensätze und Roh-Exporte um, wobei ein Mensch jeden Skill prüft.
• Ein durchgerechnetes Beispiel zeigt, wie Agents lernen, wie Teamleiter einen Sprint tatsächlich abschließen.
• CLiF zielt auf die Schmerzen ab, die Agent-Teams ausbremsen, darunter Evals, Context Bloat, Kosten, fragmentierte Stacks und Schatten-KI-Nutzung, und läuft vollständig self-hosted.

Was das Agent-Tracing übersieht

Die meisten Agent-Observability ist heute auf den Agent ausgerichtet. Tracing-Tools erfassen Prompts, Tool-Aufrufe und Modellausgaben, was zeigt, wo der Agent einen Fehler gemacht hat, während der korrekte Weg außer Sicht bleibt. Product Analytics deckt die andere Seite mit Klicks, Funnels und Session-Replays ab, doch diese Daten sind dafür ausgelegt, dass ein Mensch ein Dashboard liest, nicht dafür, einem Agent eine Aufgabe beizubringen oder ihn zu testen. In den meisten Produktions-Stacks für Agents landen die beiden nie auf derselben Timeline.

Diese Lücke ist wichtig, weil der Agent ein Produkt aus Prompts, Skills, Tool-Beschreibungen und exponierten APIs lernt und selbst herausfinden muss, wie diese Teile für eine echte Aufgabe zusammenpassen. Die Menschen, die das Produkt nutzen, haben das bereits gelöst – oft hunderte Male. CopilotKits Sichtweise, dargelegt in seinem Erklärtext zu Agent Learning, ist, dass die Art und Weise, wie Nutzer Arbeit tatsächlich erledigen, der wertvollste Datensatz ist, den jedes Agent-Team haben kann, und dass dieser selten in einer Form erfasst wird, aus der ein Agent lernen kann.

Full-Stack-Trajektorien: Das Trainingssignal, auf dem CLiF basiert

CLiF ist Teil von CopilotKit Intelligence und baut auf einem einzigen Primitiv auf, der Full-Stack-Trajektorie. Sie wird über AG-UI (Agent-User Interaction Protocol)erfasst, das offene Protokoll, das CopilotKit geschaffen hat, um Agents mit nutzergerichteten Anwendungen zu verbinden. Da AG-UI auf jeder Oberfläche zwischen dem Agent und dem Nutzer sitzt, kann es beide Seiten einer Aufgabe sehen:

• Agent-Trajektorie (Agent-Trace): jeder Lauf, jeder Tool-Aufruf und jede Zustandsänderung, die der Agent vorgenommen hat, und was jeder davon zurückgegeben hat.
• Produkt-Trajektorie (Nutzeraktionen): was auf dem Bildschirm des Nutzers zu sehen war, welche Schaltflächen er angeklickt hat und welche Serveranfragen er ausgelöst hat. Wenn der Nutzer dabei mit dem Agenten spricht, landet diese Unterhaltung in derselben Reihenfolge auf derselben Timeline.

Zusammen ergibt das eine Full-Stack-Trajektorie.

AG-UI streamt die Ereignisse des Agenten bereits zum Frontend, sodass die sichere Erfassung von Nutzeraktionen über dasselbe Protokoll beide Hälften von Anfang an in einen Stream legt – ohne separate Analytics-Pipeline, die sie später zusammenfügen müsste. Jede Nutzersitzung wird zu einer einzigen Trajektorie, die ein Team in CopilotKit Intelligence öffnen und Schritt für Schritt abspielen kann, mit Klicks, Serveranfragen und Agentennachrichten in der Reihenfolge, in der sie stattfanden.

Inside CLiF: Von Trajektorien zu Skills, Evals und Trainingsdaten

CopilotKit beschreibt die Lernschleife in vier Phasen.

1. Erfassen. Trajektorien strömen in CopilotKit Intelligence ein und werden Lern-Containern zugewiesen, die das Lernen auf eine Art von Arbeit begrenzen, etwa Rechnungssupport oder Customer Onboarding. Die Runtime wählt den Container für jede Sitzung über den getTrajectoryLearningContainerIds-Callback aus, und Sitzungen können später in der Intelligence-UI in einen Container verschoben oder daraus entfernt werden. Jeder Container lernt nur aus seinen eigenen Sitzungen.

2. Muster finden. Die Analyse läuft nach einem Zeitplan, sobald ein Container einen festgelegten Schwellenwert neuer Sitzungen überschreitet, und Teams können sie auch manuell auslösen. Jeder Durchlauf arbeitet mit einem eingefrorenen Schnappschuss der Sitzungen des Containers und liefert Insights: wiederkehrende Anfragen, wiederholte Korrekturen und die Reibungspunkte, die Nutzer stillschweigend umgehen. CopilotKit betrachtet diese Reibung als das stärkste Signal, da sie sich über Tausende von Sitzungen hinweg wiederholt und genau zeigt, was der Agent als Nächstes lernen sollte. Jeder Insight nennt die konkreten Ereignisse, auf denen er basiert, und verlinkt direkt auf die Quell-Trajektorie.

3. Prüfen. Wenn die Belege eine wiederverwendbare Lektion stützen, schlägt CLiF sie als Skill vor, geschrieben als einfache SKILL.md-Datei. Der Analysedienst kann nichts eigenmächtig veröffentlichen: Eine Person genehmigt oder lehnt jeden Vorschlag ab, entweder in der Intelligence-UI oder über die CopilotKit-CLI. Veröffentlichte Skills werden versioniert und können jederzeit zurückgezogen werden.

4. Ausliefern und exportieren. Veröffentlichte Skills erreichen den Agenten ohne Redeployment, und Teams, die Stabilität benötigen, können den Agenten auf eine feste Skill-Revision pinnen. Für jeden anderen Agenten oder MCP-Server können Skills als einfache Dateien mit copilotkit skills download <container> –output <dir> heruntergeladen werden. Die Trajektorien selbst können als rohe Ereignisdaten aus dem Intelligence-Dashboard exportiert werden. Für Early-Access- Teams erzeugt dieselbe Pipeline auch Eval-Kandidaten und Fine-Tuning-Datensätze aus diesen Trajektorien.

Agent Trajectories: Automatisches Lernen in CopilotKit Intelligence

Auf der Agentenseite baut CLiF auf Automatic Learningauf, der Fähigkeit in CopilotKit Intelligence, die CopilotKit auch als Grundlage für selbstverbessernde Agentenpositioniert. Automatic Learning lernt aus den Gesprächen, die Nutzer mit dem Agenten führen. CLiF erweitert dieselbe Schleife auf Produkt-Trajektorien, sodass es auch aus der Arbeit lernt, die Nutzer direkt im Produkt außerhalb des Chats erledigen.

Jedes Agentengespräch wird vollständig über AG-UI Streamsgespeichert: Nachrichten, Tool-Aufrufe, generative UI, State, Freigaben und Dateien. Entwickler entscheiden, welche Threads als Beleg zählen, indem sie eine Container-ID aus dem getLearningContainerId-Callback auf der CopilotKit-Runtime zurückgeben, dem agentenseitigen Gegenstück zum Trajektorien-Callback. Teams, die bereits einen Agenten in Produktion haben, können bestehende Historie aus einem LangGraph Server oder LangSmith Deployment importieren, statt bei null anzufangen.

Die Skill-Auslieferung funktioniert über Adapter für LangGraph (Python und TypeScript), Mastra, Google ADK, Microsoft Agent Framework, CopilotKit’s eingebauten Agenten und mehr. Der Adapter fügt einen Katalog und zwei Tools hinzu, copilotkit_load_skill und copilotkit_read_skill_file, und das Modell lädt einen Skill, wenn die Aufgabe es erfordert. Entwickleranweisungen behalten Vorrang, sodass Skills die Rolle des Agenten, Sicherheitsregeln oder Tool-Einschränkungen nicht überschreiben können.

Über Skills hinaus: Evals, Fine-Tuning-Daten und rohe Trajektorien

Skills sind nur die erste Ausgabe. Dieselben Trajektorien speisen insgesamt vier Ausgaben, alle in den bestehenden Stack eines Teams exportierbar:

1. Skills für Agenten oder MCP-Server, aufgebaut aus Mustern, die über viele Sitzungen hinweg wiederkehren.
2. Produktionsbasierte Evals, aufgebaut aus Aufgaben, die Nutzer tatsächlich ausgeführt haben, einschließlich der Eingaben und Randfälle, an die niemand gedacht hätte, sie von Hand zu schreiben. Diese können in die Eval-Plattform exportiert werden, die ein Team bereits nutzt.
3. Fine-Tuning-Datensätze aus echten Aufgaben-Trajektorien, gedacht zum Training kleinerer, schnellerer offener Modelle auf den häufigsten Workflows eines Unternehmens.
4. Rohe Full-Stack-Trajektorien , die in jede Observability-Plattform exportiert oder von einem Team beliebig verwendet werden können.
   

CopilotKit vertritt die Auffassung, dass Teams die Eval- und Observability-Tools behalten sollten, die sie bereits nutzen, und CLiF liefert die Daten, die diesen Tools bisher gefehlt haben.

CLiF in Aktion: Ein praktisches Beispiel

Angenommen, Sie sind CTO einer Projektmanagement-Plattform ähnlich wie Linear, in der Engineering-Teams Sprints planen und Issues verfolgen. Sie möchten, dass Agents routinemäßige Arbeit in Ihrem Produkt übernehmen und dabei zuverlässig arbeiten – sowohl Ihr eigener integrierter Agent als auch externe Agents wie Claude, die Kunden über Ihren MCP-Server anbinden. Der Abschluss eines Sprints ist eine der ersten Aufgaben auf der Liste.

Ihre Plattform verfügt bereits über eine Ein-Klick-Option, die jedes unfertige Issue in den nächsten Sprint verschiebt, und Ihre Dokumentation beschreibt den Sprint-Abschluss genau so. Wenn ein Agent also beauftragt wird, einen Sprint abzuschließen, tut sie genau das und verschiebt jedes unfertige Issue nach vorn.

Sobald CLiF Produkt-Trajektorien sicher erfasst, zeigen Tausende von Sprint-Abschlüssen, dass Teamleitungen auf Ihrer Plattform mehr tun als das. Die meisten nutzen die Ein-Klick-Option und verbringen dann die nächsten Minuten damit, das Ergebnis zu korrigieren:

• Sie verschieben Issues, die bereits einmal übertragen wurden, zurück ins Backlog und heben ihre Zuweisung auf.
• Sie kommentieren blockierte Issues und markieren die Person, die für die Blockade verantwortlich ist.

Niemand in Ihrem Team hat diese Routine entworfen, und nur wenige Nutzer würden sie auf Nachfrage beschreiben. Sie existiert nur in den Klicks und Anfragen, die auf den Ein-Klick-Schritt folgen. Agent-Traces sehen sie nie, weil Nutzer sie selbst ausführen. Product Analytics zeichnet die zusätzlichen Klicks ohne ihre Bedeutung auf, und das Muster in Session-Replays zu erkennen, würde bedeuten, tausende Aufzeichnungen anzusehen.

CLiF macht die Routine als Insight sichtbar, verweist auf die exakten Sessions dahinter und schlägt einen Skill für den vollständigen Close-Out vor. Nachdem Ihr Team ihn geprüft und veröffentlicht hat, übernimmt Ihr integrierter Agent ihn ohne Redeployment, und Sie liefern denselben Skill mit Ihrem MCP-Server aus, sodass Claude und andere verbundene Agenten ihm ebenfalls folgen. Wenn sich Nutzergewohnheiten ändern, halten neue Sessions den Skill aktuell, und das Insight zeigt Ihnen außerdem, wo Ihr eigenes Feature Lücken hat.

Dieselben Sessions werden zu Eval-Cases, die prüfen, ob ein Agent jedes Problem so behandelt, wie es Team-Leads auf Ihrer Plattform tun, sodass Sie bestätigen können, dass Agenten bereit sind, bevor Sie ihnen die Aufgabe übergeben. Sie können auch zu Trainingsdaten werden, wenn Sie später ein kleineres Modell für Planungsarbeit feintunen.

Wie CLiF die Probleme angeht, die Agent-Teams 2026 bremsen

Für technische Führungskräfte, die Agenten im großen Maßstab betreiben, positioniert CopilotKit CLiF als Antwort auf ein bekanntes Set von Problemen.

• Agenten an Evals vorbeibringen: Für die meisten Teams ist der langsamste Teil des Auslieferns eines Agenten, ihn genug Evals zu den wichtigen Workflows bestehen zu lassen. Skills, die aus der Art und Weise gelernt werden, wie Nutzer diese Workflows abschließen, geben dem Agenten die fehlenden Schritte. Produktionsbasierte Evals ergänzen dann die Randfälle, auf die Nutzer in der Praxis stoßen, sodass die Suite mit der realen Nutzung weiterwächst.
• Context-Bloat und Tool-Überlastung: Jeder Agentenfehler endet tendenziell mit einer weiteren Regel im System-Prompt oder einem weiteren Tool am Agenten. Mit der Zeit füllt sich der Kontext, und das Verhalten wird schwerer vorhersehbar. CLiF hält gelerntes Verhalten stattdessen in einem Skill-Katalog, und das Modell lädt einen Skill nur, wenn die Aufgabe es verlangt.
• Kosten: Agenten werden tendenziell teurer, je mehr Tools und längere Prompts sie erhalten. Fine-Tuning-Datensätze aus echten Trajektorien geben Teams einen Weg, hochvolumige Workflows auf kleinere, günstigere Open-Modelle zu verlagern, und Container pro Workflow zeigen, wo ein Agent Schwierigkeiten hat und wo nicht.
• Fragmentierte Stacks: Große Organisationen einigen sich selten auf ein einziges Agent-Framework, und ihre Agenten leben in Web-Apps, mobilen Apps, Slack und Teams. CLiF läuft auf AG-UI und funktioniert daher mit jedem Agent-Harness und jedem zugrunde liegenden Modell. AG-UI wird von Google, Microsoft, Anthropic, Amazon und Oracle unterstützt sowie von Frameworks einschließlich LangChain, Mastra, Pydantic AI, Google ADK und weiteren.
• Agenten-Adoption außerhalb zentraler Kontrolle: Da Teams eigenständig Agent-Tooling einführen, wird es schwieriger zu wissen, was jeder Agent gelernt hat und warum. Jeder CLiF-Skill durchläuft eine menschliche Prüfung, lässt sich bis zu den Sessions zurückverfolgen, aus denen er stammt, und bleibt versioniert und reversibel. Die gesamte Plattform kann zudem innerhalb der eigenen Infrastruktur eines Unternehmens betrieben werden.

Selbst-Hosting von Grund auf

CLiF ist vollständig selbst-hostbar. CopilotKit Intelligence kann selbst gehostet auf dem eigenen Kubernetes-Cluster eines Unternehmens mit einem Helm-Chart betrieben werden, oder auf AWS ECS und Fargate, mit der eigenen Postgres-, Redis- und Identitätsinfrastruktur des Teams, etwa Okta, Azure AD oder Keycloak.

Trajektorien, Skills und alles, was daraus gelernt wird, bleiben innerhalb der VPC oder der On-Premises-Umgebung des Unternehmens, sodass Nutzeraktivität und Agent-Traces niemals das Netzwerk verlassen müssen. Traces können auch in einen bestehenden OpenTelemetry-Collector fließen. CopilotKit Intelligence läuft auch in einer Managed Cloud für Teams, die das schnellste Setup wünschen.

Kernpunkte

• CopilotKit hat CLiF veröffentlicht, eine Plattform für kontinuierliches Lernen aus Full-Stack-Trajektorien, jetzt in Early Access als Teil von CopilotKit Intelligence.
• Wie Nutzer die Arbeit bereits erledigen, ist das Signal, das Agenten fehlt. Full-Stack-Trajektorien erfassen sie zusammen mit dem Agent-Trace, auf einer Timeline über AG-UI.
• CLiF wandelt diese Trajektorien in vier Ausgaben um: produktionsbasierte Evals, Fine-Tuning-Datensätze für kleinere Open-Modelle, Skills für Agenten oder MCP-Server und rohe Trajektorien zum Export – alles kompatibel mit bestehenden Eval- und Observability-Stacks.
• Ein Mensch prüft jeden Skill, und jedes davon lässt sich bis zu seinen Quellsitzungen zurückverfolgen. Veröffentlichte Skills erreichen den Agenten ohne Redeploy und können mit einem MCP-Server für externe Agenten wie Claude ausgeliefert werden.
• Es zielt auf die zentralen Schmerzen beim Betrieb von Agenten im großen Maßstab ab: bestandene Evalsläufe, Context-Bloat, Kosten, fragmentierte Stacks und die Aufsicht darüber, was jeder Agent gelernt hat.
• CLiF funktioniert mit jedem Agent-Framework und jedem Modell über AG-UI, und es ist vollständig self-hostable.

Teams können mehr erfahren, eine Demo buchen oder Early Access auf der CLiF-Seite anfordern.

Referenzen

• CLiF-Produktseite
• Wir stellen CLiF vor: Die Plattform für kontinuierliches Lernen für KI-Agenten auf Basis von Full-Stack-Trajektorien (CopilotKit-Blog)
• Was ist Agentenlernen? (CopilotKit)
• CLiF-Launchvideo
• CopilotKit Intelligence
• Automatic Learning-Dokumentation
• Skill Delivery-Dokumentation

_{Dank an das Copilotkit-Team für die Thought Leadership / Ressourcen zu diesem Artikel. Dieser Artikel wird von Copilokit gesponsert.}

Der Beitrag CopilotKit veröffentlicht CLiF: Eine Continuous-Learning-Plattform, die Agent-Traces und Nutzeraktionen in Skills, Evals und Fine-Tuning-Daten umwandelt erschien zuerst auf MarkTechPost.