KI-Agenten erstellen: ein kleines Werkzeug, klare Grenzen

Was einen KI-Agenten vom festen Ablauf unterscheidet

Ein festes Programm arbeitet vorgegebene Schritte ab. In einem Agentenablauf kann das Modell entscheiden, ob es ein angebotenes Werkzeug aufruft und welche zulässigen Argumente es übergibt. Die Anwendung führt den Aufruf aus und gibt das Ergebnis an das Modell zurück. Daraus entsteht eine Schleife bis zur Antwort oder einem Abbruch. Der Planungsleitfaden zur KI-Automatisierung hilft dir zu entscheiden, ob für deinen Vorgang ein fester Ablauf statt eines Agenten genügt.

Das Modell erfindet dadurch keine echte technische Fähigkeit. Ein Werkzeug muss implementiert und mit passenden Rechten angebunden sein. Ein Prompt wie „Du darfst nichts löschen“ entzieht einem vorhandenen Schreibzugang keine Berechtigung.

Unser erster Agent soll nur eine fiktive Wartungskarte lesen und ihren Status erklären. Der nächste menschliche Schritt bleibt eine Empfehlung. Wenn später ein externer Werkzeugserver hinzukommt, kannst du im Grundlagenartikel MCP als Werkzeugverbindung verstehen: Protokoll, Modell und tatsächliche Dienstrechte erfüllen verschiedene Aufgaben.

Den passenden technischen Einstieg wählen

Die aktuelle Laufzeitübersicht trennt diese Wege. Für unseren kurzen Code wählen wir das SDK. Das ist keine Aussage, dass es für jede Firma oder jeden Hoster die beste Lösung ist. Ein statischer Website-Ordner führt einen Python-Agenten nicht automatisch aus.

Zum bisherigen Agent Builder: OpenAI kündigt dessen Abschaltung zum 30. November 2026 an. Die Übergangsdokumentation ist deshalb kein guter Startpunkt für ein neues langfristiges Builder-Projekt.

Wenn du zuerst feste Zustände und Übergänge lernen möchtest, kannst du Zustände und Abläufe mit LangGraph aufbauen. Ein deterministischer Ablauf und ein modellgesteuerter Agent bleiben dabei unterschiedliche Lernschritte.

Nicht jede Werkzeugwahl braucht einen frei formulierenden Agenten. Wenn die erlaubten Ergebnisse schon feststehen, kannst du Clef für begrenzte Entscheidungen einordnen: Ein Ticket wird beispielsweise einer vorgegebenen Warteschlange zugeordnet. Die tatsächlichen Zugriffsrechte und Freigaben bleiben Aufgabe der Anwendung.

Eine getrennte Pythonumgebung vorbereiten

Lege einen eigenen Übungsordner an. Die SDK-Kurzanleitung nennt für Python das Paket openai-agents; der Import heißt agents. Die folgenden Befehle installieren es in einer getrennten Umgebung.

python -m venv .venv

.\.venv\Scripts\Activate.ps1
python -m pip install openai-agents

source .venv/bin/activate
python -m pip install openai-agents

Wenn die Aktivierung auf deinem Rechner durch Richtlinien gesperrt ist, ändere nicht pauschal die Systemsicherheit. Nutze die Pythondatei der virtuellen Umgebung direkt oder kläre die Vorgabe mit der zuständigen Administration.

Für den optionalen Modellversuch brauchst du einen API-Zugang mit freigeschaltetem Modell und passender Abrechnung. Der Beispielcode fragt den Schlüssel verdeckt ab und setzt ihn nur für diesen Prozess. Er gehört nicht in die Datei oder einen Screenshot. SDK-Tracing ist außerdem ein eigener Datenweg; verwende hier ausschließlich die künstlichen Datensätze. Für einen späteren gemeinsamen Modellzugang erklärt LiteLLM als Modell-Gateway den Proxy-Aufbau, Anwendungsschlüssel und Budgetgrenzen.

Einen Agenten mit genau einem lesenden Werkzeug erstellen

Speichere den folgenden eigenen Lehrcode als werkstatt_agent.py. Er verbindet einen echten SDK-Agenten mit einer kleinen Pythonfunktion. Die Funktion liefert nur Daten aus dem eingebauten Beispieldictionary. Sie öffnet keine Datei, kontaktiert keinen Wartungsdienst und führt keine Shell aus.

import asyncio
import getpass
import json
import os
from agents import Agent, Runner, function_tool

KARTEN = {
    "TW-A-01": {"status": "offen", "pruefung": "Kabel beschriften"},
    "TW-A-02": {"status": "geprueft", "pruefung": "Abnahme dokumentieren"},
}

def karte_lesen(karten_id: str) -> str:
    if karten_id not in KARTEN:
        return json.dumps({"fehler": "Unbekannte Karten-ID"})
    return json.dumps({"id": karten_id, **KARTEN[karten_id]}, ensure_ascii=False)

@function_tool
def wartung_lesen(karten_id: str) -> str:
    """Liest genau eine fiktive Wartungskarte; ändert nichts."""
    return karte_lesen(karten_id)

async def main():
    os.environ["OPENAI_API_KEY"] = getpass.getpass("API-Schlüssel: ")
    modell = input("Freigeschaltete Modell-ID: ").strip()
    if not modell:
        raise ValueError("Eine Modell-ID ist erforderlich.")
    agent = Agent(
        name="Werkstatt-Lesehilfe",
        model=modell,
        instructions=(
            "Lies Wartungsdaten nur mit wartung_lesen. "
            "Erfinde keine ID oder fehlende Angaben. "
            "Melde fehlende IDs und unerlaubte Änderungswünsche. "
            "Gib Status, Prüfschritt und verwendete ID aus."
        ),
        tools=[wartung_lesen],
    )
    frage = input("Auftrag mit Karten-ID: ")
    result = await asyncio.wait_for(
        Runner.run(agent, frage, max_turns=4), timeout=45
    )
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

Starte die Datei in deiner Umgebung mit python werkstatt_agent.py. Gib eine für deinen API-Zugang verfügbare Modell-ID ein. Die Modellverarbeitung erfolgt beim gewählten Dienst und kann kostenpflichtig sein; die zwei Beispieldatensätze werden dabei Kontext.

Vier Modellschritte und 45 Sekunden begrenzen diesen kleinen Versuch technisch. Der lokale Timeout ist keine garantierte Kostenobergrenze und kein Beleg, dass ein entfernter Dienst sofort jede Verarbeitung beendet. Die Laufzeitreferenz unterscheidet Antworten, Fehler und bewusst pausierte Läufe.

Code und eigenen Prüfplan als Textdatei herunterladen. Der Code wurde statisch geprüft; ein SDK-Lauf mit einem Anbieter wurde für diesen Artikel nicht ausgeführt.

Schreibaktionen vor der Ausführung anhalten

Ein späteres Werkzeug wie „Wartung abschließen“ wäre eine neue Fähigkeit mit Außenwirkung. Prüfe dessen Argumente direkt an der Funktion und pausiere vor der Änderung. Zeige dem Menschen die konkrete Karte und vorgeschlagene Änderung. Eine allgemeine Zustimmung am Anfang ist dafür keine automatisch passende Fachfreigabe.

Die Freigabenhilfe beschreibt Unterbrechungen und einen fortsetzbaren Zustand. Die Anwendung genehmigt oder verwirft den ausstehenden Aufruf und setzt denselben Lauf fort. Ein Beispiel, das alle Unterbrechungen automatisch genehmigt, wäre für diese Aufgabe keine menschliche Prüfung.

Eingangs- und Ausgangsguardrails schützen bestimmte Grenzen, nicht automatisch jeden Werkzeugaufruf. Rechte im Zielsystem, Argumentprüfung und eine tatsächliche Freigabe gehören deshalb zusammen. Wenn dein Werkzeug aus einem Workflow kommt, kannst du MCP-Werkzeuge in n8n gezielt freigeben; auch dort sollte der erste Versuch nur die benötigte lesende Funktion anbieten.

Vier Fälle vor dem Ausbau prüfen

Notiere pro Versuch Modell-ID, Datum, Toolaufrufe, Antwort, Fehler und tatsächliche Kosten. Lies nicht nur das abschließende „Erledigt“. Kontrolliere, ob ein Tool überhaupt aufgerufen wurde und ob die Antwort seine Daten korrekt wiedergibt.

Die Eval-Anleitung empfiehlt zunächst die Untersuchung von Abläufen und danach wiederholbare Datensätze. Unsere eigenen lokalen Prüfungen betreffen nur die kleine Lesefunktion und die Syntax. Sie messen keine Modellqualität, Agentenzuverlässigkeit oder Produktionsreife.