Startseite / Artikel

Verwaltung von KI-Agenten mit dem CARE-Framework: Klarheit, Autonomie und mehr

Verwaltung von KI-Agenten mit dem CARE-Rahmenwerk: Klarheit, Autonomie, Beziehung und Gleichheit bei der Delegation, Agentenverträgen, Modellwahl und Kontext.

Verlag: REACTAPP.TOP7 Min. Lesezeit1565 Wörter

Quellen: You Already Know How to Manage Agents: The CARE Framework for AI Engineering

Management-Trainings lehren manchmal Dinge, die sich auf Software direkter anwenden lassen, als erwartet. Das CARE-Modell aus Führungstrainings, mit seinen vier Prinzipien Klarheit, Autonomie, Beziehung und Gleichheit, entspricht fast eins zu eins den etablierten Vorgehensweisen bei der Steuerung von KI-Agenten. Wenn man bei der Arbeit mit Agenten denselben Prinzipien folgt, ist das ein vernünftiger Weg, bessere Ergebnisse zu erzielen. Im Folgenden wird jedes Prinzip im Zusammenhang mit einem KI-Agenten betrachtet, der die Rolle des dem Teammitglied übertragenen Mitarbeiters einnimmt.

Der aktuelle Stand

Vor einem oder zwei Jahren sah die Arbeit mit einem Programmierassistenten wie eine Abfolge kleiner Befehle aus: eine Funktion erstellen, einen Fehler beheben, Tests hinzufügen. Heute können KI-Agenten in einem Repository blättern, Shell-Befehle ausführen, in der Dokumentation nachschauen, mehrere Dateien gleichzeitig bearbeiten, Tests ausführen und die Arbeit an Unteragenten weitergeben. Dennoch werden sie oft immer noch wie Autocomplete-Funktionen verwaltet. Das Engpassproblem liegt zunehmend nicht mehr im Abrufen von Anweisungen, sondern in der Delegation.

Die vier CARE-Fragen kurz gesagt:

  • Klarheit: Wie sieht Erfolg aus?
  • Autonomie: Wie viel kann die Person selbst entscheiden?
  • Beziehung: Wer sollte diese Arbeit erledigen?
  • Gerechtigkeit: Was brauchen sie, um erfolgreich zu sein?

Technische Manager und Leiter wissen bereits, wie wichtig jede dieser Aspekte ist, um gute Ergebnisse zu erzielen, ohne ständig über die Ausführenden zu wachen.

Klarheit: Definieren Sie die Ergebnisse, nicht die Anfragen

Nehmen wir an, ein Interessengruppenmitglied wünscht Caching am Benutzerprofil-Endpunkt, und die Ausführung soll von einem GenAI-Agenten übernommen werden. Eine typische schwache Anfrage lautet: „Implementieren Sie Caching für den Benutzerprofil-Endpunkt.“ Für jemanden, der das System kennt, klingt das klar – doch in Wirklichkeit ist es das nicht. Der Agent hat Dutzende offener Fragen: Welcher Endpunkt genau? Was wird gecacht? Für wie lange? Was macht einen Eintrag ungültig? Welche Caching-Infrastruktur existiert bereits? Was gilt als erledigt?

Klarheit bedeutet nicht eine längere Anfrage. Sie bedeutet, dass das gewünschte Ergebnis sowie die Einschränkungen eindeutig sind. Eine stärkere Formulierung dieser Aufgabe:

Goal:
Reduce repeated database reads from GET /users/{id}.

Constraints:
- Use the existing Redis abstraction.
- Do not introduce a new dependency.
- Cache only successful responses.
- TTL: 10 minutes.
- Existing public API behavior must not change.

Before implementing:
- Inspect similar caching implementations in the repository.
- Identify how cache invalidation is handled elsewhere.

Validation:
- Existing tests must pass.
- Add tests for cache hit, cache miss, and invalidation.

Definition of done:
The implementation is complete when the endpoint behaves identically
from the client's perspective and repeated reads no longer hit MSSQL.

Prompt-Engineering ist nur ein Aspekt der Klarheit. Die wahre Fähigkeit besteht darin, Aufgaben so gut zu beschreiben, dass andere sie ausführen können – etwas, was Führungskräfte und Leiter täglich tun.

Autonomie: Verantwortung, nicht nur Anweisungen

Es mag scheinen, als gäbe es bei Agenten kein Mikromanagement, aber doch. Wenn ein Agent ständige Anstöße benötigt, liegt die übliche Ursache in mangelnder Klarheit und Anweisungen. Stellen Sie sich eine solche Sitzung vor:

Find the problem.
Okay, fix it.
Now run the tests.
There's an error. Fix that.
Run them again.

Der Benutzer steuert jeden Schritt manuell, was beide Seiten ermüdet.

Ein Agent kann eine Aufgabe perfekt verstehen und dennoch keine Autonomie haben. Autonomie bedeutet Verantwortung: Was der Agent entscheiden darf, was er ändern kann, wie weit er eigenständig vorgehen sollte und wann er eskalieren muss. Ein Agentenvertrag drückt dies gut aus:

You own this task until it is implemented and validated.

You may:
- inspect any file in the repository
- modify files related to this feature
- run builds, tests and static analysis
- create focused subagents for research or validation

After implementation:
1. Run the relevant test suite.
2. Inspect your diff for unintended changes.
3. Validate the implementation against the acceptance criteria.
4. Fix issues you discover before returning.

Escalate only if:
- the requested behavior conflicts with existing architecture
- required credentials/access are unavailable
- the change would require modifying a public API

Klarheit bestimmt das Ziel, und Autonomie bestimmt, wie viel von der Reise der Agent selbst steuert. Autonomie bedeutet jedoch nicht, dass er tun kann, was immer er will – eine gesunde Autonomie geht mit Grenzen einher.

Beziehung: Die Agenten kennen

Unter Beziehung versteht man hier die Kalibrierung, nicht Anthropomorphisierung. Es handelt sich um das angesammelte Wissen über Stärken, Schwächen, Fehlermuster sowie die Leistungsbilanz der verwendeten Modelle und Agenten. Ein Manager lernt heraus, wo jede Person ihre beste Arbeit leistet – dieses Verständnis sollte auch für eine KI-Infrastruktur entstehen:

| Work                                  | Agent/model characteristic          |
| ------------------------------------- | ----------------------------------- |
| Repository-wide architecture research | Strong reasoning + large context    |
| Small mechanical refactor             | Fast, inexpensive model             |
| UI implementation from screenshots    | Strong vision model                 |
| Test generation                       | Fast coding specialist              |
| Final architecture critique           | Independent high-reasoning reviewer |

Eine Konfiguration mit einem Modell, einem riesigen Kontext und allen Aufgaben, die ihm übertragen werden, ist bei weitem nicht ideal. Die Arbeit sollte an dafür geeignete Agenten verteilt werden. Bei mehragentigen Systemen geht es nicht darum, mehr Agenten zu haben, sondern darum, gut abgegrenzte Aufgaben dem am besten geeigneten Agenten zuzuweisen:

Main Agent
│
├── Research Agent
│   └── Investigate existing caching patterns
│
├── Implementation Agent
│   └── Make the code change
│
└── Reviewer Agent
    └── Validate implementation independently

Die Beziehung verbessert sich, je mehr das System Wissen über Architekturentscheidungen, Codierkonventionen, wiederkehrende Fehlermuster, frühere Entscheidungen sowie darüber sammelt, welche Modelle bei welchen Aufgaben gut funktionieren. Kurz gesagt: Die Beziehung ergibt sich aus Modellkompetenz plus angesammeltem Kontext.

Gerechtigkeit: Das Nötige für den Agenten bereitstellen

Eine häufige Beschwerde lautet „die KI hat wieder Halluzinationen erzeugt“ oder „sie hat minderwertige Ergebnisse geliefert“. Doch man sollte sich ansehen, was dem Agenten tatsächlich zur Verfügung stand. Es gab weder API-Dokumentation noch Anforderungen zu Tickets, keine Logs, keinen Beispielcode, keine Architekturnotizen und keinen Zugang zur laufenden Anwendung. War das ein Modellversagen – oder wurde jemand gebeten, ein Problem ohne die erforderlichen Informationen zu lösen?

Nehmen wir an, der Agent könnte all das finden oder erhalten:

.agent/
│
├── context/
│   ├── architecture.md
│   ├── domain.md
│   └── conventions.md
│
├── skills/
│   ├── debug-production.md
│   ├── review-mr.md
│   └── implement-feature.md
│
├── references/
│   ├── api-spec/
│   ├── examples/
│   └── decisions/
│
└── tools/
    ├── git
    ├── jira
    ├── logs
    ├── browser
    └── tests

Die genaue Struktur ist weniger wichtig als das Prinzip. Agenten benötigen richtige Anweisungen und Werkzeuge. Ein Produktions-Debugging-Agent kann Code, Protokolle, Spuren, kürzliche Bereitstellungen sowie Git-Historie benötigen. Ein UI-Agent benötigt möglicherweise Code, ein Screenshot, das Design-System, einen Browser sowie Dokumentationen zu Komponenten. Ein Prüfer benötigt den Diff, die vollständige Datei, Tests, das Ticket, ähnlichen Code sowie die Richtlinien des Repositoriums. Die Intelligenz bleibt dieselbe, die Anforderungen unterscheiden sich. Bevor man schließt, dass das Modell nicht fähig ist, sollte man prüfen, ob es dafür ausgestattet war.

CARE als Debugging-Tool

Die Richtung der Arbeit entwickelt sich von der Anleitung über die Delegation bis zur Koordination, und die Rolle des Leiters ändert sich entsprechend. Begabte Menschen leisten bereits bei unklaren Zielen, Mikromanagement, nicht passenden Aufgaben oder fehlenden Ressourcen schlechte Arbeit. Wenn dieses Wissen auf Agenten angewandt wird, funktionieren dieselben Managementgewohnheiten nun für alle, die in einem Team Lösungen entwickeln – egal ob menschlich oder nicht.

Alle vier Aspekte in einer Agentendefinition

Die Implementierungen unterscheiden sich in ihrem Schema, doch eine funktionierende Agentendefinition integriert in der Regel CARE in etwas wie Folgendes:

---
name: implementation-agent
description: Implements scoped repository changes end-to-end. Use proactively for feature, bug-fix, and refactor tasks that require code changes and validation.
tools: Read, Grep, Glob, Edit, Write, Bash
model: inherit
---

You are an implementation agent responsible for completing scoped coding tasks end-to-end.

When given a task:

1. **Investigate**
   - Read the relevant code before changing it.
   - Search for similar implementations and existing project conventions.
   - Do not guess when repository evidence is available.

2. **Plan**
   - Form a short plan covering the files to change, the implementation approach, and validation.

3. **Implement**
   - Make the smallest change that fully satisfies the task.
   - Reuse existing patterns and dependencies.
   - Do not modify unrelated code.

4. **Validate**
   - Run the relevant tests, build/type-check, and lint/static analysis when available.
   - If your change causes a failure, fix it and validate again.

5. **Review**
   - Inspect the final diff.
   - Remove accidental or unrelated changes.
   - Confirm the requested behavior and acceptance criteria are satisfied.

Continue autonomously until the task is complete.

Escalate only when required access is unavailable, requirements materially conflict, or the task would require a destructive action or a public API/architecture change outside the requested scope.

The task is done only when the implementation is complete, relevant validation passes, and the final diff has been reviewed.

Delegation ist die wichtige Fähigkeit der Gegenwart

Agenten sind keine Menschen, doch die um sie herum gebauten Systeme leiden unter überraschend bekannten Managementfehlern. Geben Sie einem Agenten ein unklares Ziel, steuern Sie jeden Schritt, weisen Sie das falsche Modell zu oder vorenthalten Sie Kontext und Werkzeuge – dann sinkt die Leistung. Wenn Agenten leistungsfähiger werden, beschränkt sich der Vorteil nicht auf stärkere Modelle oder präzisere Anweisungen. Teams, die lernen, gut zu delegieren, werden am meisten aus KI herausholen.