Eine KI‑Agentin (inkl. m/w/d, im Folgenden: KI‑Agent*in) ist ein System mit eigenem Ziel, Planung, Werkzeugen (Tools/APIs), Gedächtnis und Rückkopplungsschleife. Im Gegensatz zum klassischen Chatbot (regelbasiert) oder reaktiven KI‑Assistenten (LLM‑Chat ohne Autonomie) kann ein KI‑Agent*in selbstständig Schritte wählen, Informationen einholen und Aufgaben abschließen – nicht nur Antworten texten.

Transparenz & Rahmen: Dieser Beitrag z.B. folgt den Leitplanken unseres Master‑/Servantring‑Workflows „Der KI‑Kompass für Studierende“.

---

Lernziele

• Du kannst KI‑Agent*in, Chatbot und Assistent unterscheiden.
• Du kennst die Bausteine eines Agenten (Ziel, Planung, Tools, Gedächtnis, Schleife).
• Du kannst einen Minimal‑Agenten in JSON konfigurieren.
• Du weißt, Risiken (Datenschutz, Halluzinationen) zu erkennen und zu mindern.

---

Begriffe einfach erklärt

Chatbot (klassisch)

• Regelbasiert oder mit einfachen Intent‑Antwort‑Bäumen.
• Reagiert auf feste Muster (FAQ, Menü, Buttons).
• Keine Autonomie, kein Tool‑Einsatz.

KI‑Assistent (LLM‑Chat)

• Nutzt ein großes Sprachmodell (z. B. „ChatGPT“‑ähnlich).
• Reaktiv: Antwortet auf deinen Prompt, oft ohne langfristiges Gedächtnis.
• Kann Tools nutzen, entscheidet aber normalerweise nicht eigenständig, wann und wie es weiterarbeitet.

KI‑Agent*in

• Hat Ziele (Objectives) und plant mehrere Schritte (Planer/Reasoner).
• Nutzt Tools/APIs (z. B. Websuche, Kalender, E‑Mail, Python) – handelt im System.
• Führt eine Rückkopplungsschleife (Perception → Thought/Plan → Action → Observation) aus.
• Besitzt Gedächtnis (Kurzzeit: Kontextfenster; Langzeit: Vektorspeicher/DB).
• Kann Events abonnieren (z. B. „neue E‑Mail“, „Frist erreicht“) und proaktiv handeln.

Merksatz: Chatbots antworten, Assistenten helfen – Agentinnen handeln.*

---

Vergleich (auf einen Blick)

• Initiative: Chatbot ❌ | Assistent 🔸 | Agent*in ✅
• Mehrschritt‑Planung: Chatbot ❌ | Assistent 🔸 | Agent*in ✅
• Tool‑/API‑Zugriff: Chatbot ❌ | Assistent 🔸 | Agent*in ✅
• Gedächtnis/Langzeit: Chatbot ❌ | Assistent 🔸 | Agent*in ✅
• Event‑getrieben: Chatbot ❌ | Assistent 🔸 | Agent*in ✅

(🔸 = möglich, aber nicht Standard)

---

Warum ist das wichtig für Studierende?

• Recherche & Literatur: Agent*in sammelt Quellen, prüft Dubletten, schreibt kurze Abstracts.
• Studienorganisation: Fristen, Stundenplan, To‑dos – Agent*in synchronisiert Kalender und erinnert proaktiv.
• Bewerbungen & Karriere: Stellen scannen, Matching, Anschreiben‑Entwürfe, Terminvorschläge.
• Labor & Daten: Daten säubern, Ausreißer prüfen, Skripte starten, Protokoll führen.

---

Die 5 Bausteine eines KI‑Agenten

1. Ziel(e): Was soll erreicht werden? (z. B. „Finde 5 relevante Paper und fasse sie in 200 Wörtern zusammen“)
2. Wahrnehmung (Observation): Was kommt aus Tools/Umwelt zurück?
3. Planung/Reasoning: Wie zerlegt der Agent die Aufgabe? (Chain‑of‑Thought/Planner)
4. Aktionen (Tools/APIs): Welche Funktionen darf der Agent ausführen?
5. Gedächtnis (Memory): Was merkt er sich für später?

---

JSON‑Start: Ein Minimal‑Agent als Konfiguration

Nutze JSON, um Konfiguration, Tools und Zustand klar zu trennen. So kannst du Agent*innen ohne großen Code anpassen.

1) agent.config.json – Rollen, Ziele, Policies

{
  "name": "StudyScout",
  "role": "Hilft Studierenden bei Recherche und Fristen",
  "goals": [
    "Finde 5 peer‑reviewte Quellen zum angegebenen Thema",
    "Erzeuge eine 200‑Wörter‑Zusammenfassung",
    "Lege Deadlines im Kalender an"
  ],
  "policies": {
    "max_steps": 8,
    "safety": ["keine Passwörter speichern", "Datenschutz: nur Metadaten teilen"],
    "rate_limits": {"requests_per_min": 30}
  },
  "planner": { "strategy": "react", "replan_on_failure": true },
  "memory": { "short_term": true, "long_term": { "type": "vector_store", "collection": "studyscout" } },
  "tools": ["web_search", "pdf_reader", "calendar"],
  "events": ["deadline_due", "new_task"]
}

2) tools.schema.json – Welche Aktionen sind erlaubt?

{
  "web_search": {
    "description": "Suche im Web nach Quellen",
    "input_schema": {"type": "object", "properties": {"query": {"type": "string"}, "limit": {"type": "integer"}}},
    "returns": {"type": "array", "items": {"type": "object", "properties": {"title": {"type": "string"}, "url": {"type": "string"}}}}
  },
  "pdf_reader": {
    "description": "Extrahiere Text aus PDF-URLs",
    "input_schema": {"type": "object", "properties": {"url": {"type": "string"}}},
    "returns": {"type": "string"}
  },
  "calendar": {
    "description": "Erzeuge Kalendereinträge",
    "input_schema": {"type": "object", "properties": {"title": {"type": "string"}, "due": {"type": "string", "format": "date-time"}}},
    "returns": {"type": "object", "properties": {"id": {"type": "string"}, "status": {"type": "string"}}}
  }
}

3) agent.state.json – Laufender Zustand

{
  "task": "Finde Literatur zu 'Explainable AI in Medizin'",
  "step": 0,
  "plan": [],
  "context": [],
  "memory_refs": [],
  "history": []
}

4) Nachrichten‑/Tool‑Aufrufe (LLM I/O)

{
  "messages": [
    {"role": "system", "content": "Du bist ein Agent, der Ziele in Schritte zerlegt und Tools verantwortungsvoll nutzt."},
    {"role": "user", "content": "Finde 5 relevante Paper zur KI‑Erklärung im Gesundheitswesen und fasse sie."}
  ],
  "tools": {
    "web_search": {"query": "explainable AI healthcare review 2023", "limit": 5}
  }
}

Tipp: Bewahre Konfiguration, Tool‑Schemas und Zustand getrennt auf. So kannst du mehrere Agent*innen mit denselben Tools betreiben.

---

Mini‑Workflow: ReAct‑Schleife (vereinfacht)

1. Perception: Lese agent.state.json und letzte Rückmeldungen.
2. Thought/Plan: LLM entwirft nächsten Schritt (z. B. Websuche).
3. Action: Rufe Tool gemäß tools.schema.json auf.
4. Observation: Schreibe Ergebnis in history und ggf. memory.
5. Check: Ziel erreicht? Sonst erneut planen (bis max_steps).

Du kannst diese Schleife in jeder Sprache implementieren (Python/JS). Das Steuer‑Protokoll bleibt JSON.

---

Erste Praxis: In 30 Minuten zum funktionierenden Agenten

Voraussetzungen: API‑Key deines LLM‑Anbieters, ein Terminal, Node.js oder Python.

Schritte:

1. Repo anlegen (agent.config.json, tools.schema.json, agent.state.json).
2. Tool‑Adapter schreiben (kleine Funktionen, die die JSON‑Schemas respektieren).
3. ReAct‑Loop programmieren (Plan → Tool → Observation → Update state).
4. Logging (JSON‑Logs je Schritt, inkl. Fehler, Latenzen, Costs).
5. Testfall: Kleines Recherche‑Ziel formulieren, Lauf prüfen, max_steps anpassen.

---

Sicherheit, Recht & Qualität

• Datenschutz: Keine sensiblen Personen‑/Gesundheitsdaten in Prompts. Nutzung von Pseudonymen. Speicher verschlüsseln.
• Halluzinationen mindern: Quellen prüfen, Zitationen erzwingen (Tool „web_search“ mit Verifikationsschritt).
• Rate Limits & Kosten: rate_limits setzen, Batch‑Aufrufe, Caching.
• Missbrauch verhindern: Nur nötige Tools freischalten; Eingaben validieren gegen input_schema.
• Transparenz: Markiere KI‑Anteile und Logs (z. B. im Impressum/Datenschutzhinweis).

---

Beispiel‑Prompts (als JSON speicherbar)

{
  "preset_prompts": [
    {
      "name": "planner_strict",
      "system": "Zerlege jede Aufgabe in nummerierte, überprüfbare Schritte. Nutze nur die erlaubten Tools. Erkläre kurz, warum du einen Schritt wählst.",
      "constraints": ["max_steps=6", "cite_sources=true"]
    },
    {
      "name": "grader",
      "system": "Bewerte, ob das Ziel erfüllt ist. Gib eine Binärentscheidung und eine Begründung.",
      "output_schema": {"type": "object", "properties": {"done": {"type": "boolean"}, "reason": {"type": "string"}}}
    }
  ]
}

---

Häufige Stolpersteine

• Zu vage Ziele: Immer konkret (Anzahl, Umfang, Frist) – sonst Endlosschleifen.
• Keine Tool‑Rückmeldung gespeichert: Ohne Observation kann der Planer nicht lernen.
• Vermischte Dateien: Trenne Konfiguration vs. Zustand vs. Logs.

---

Checkliste: Dein erster KI‑Agent*in

• Ziele präzise formuliert (SMART)
• Tools mit klaren JSON‑Schemas
• ReAct‑Schleife implementiert
• Logging + Kostenkontrolle
• Datenschutz‑Check + Transparenzhinweis

---

FAQ (für SEO) – auch als JSON‑LD

Was ist der Unterschied zwischen Chatbot, Assistent und KI‑Agent*in? – Chatbots sind regelbasiert, Assistenten reagieren, Agent*innen handeln mit Planung, Tools und Gedächtnis.

Brauche ich Programmierwissen? – Einfache Agent*innen kannst du mit JSON‑Konfigs und wenig Code bauen. Für komplexe Tools ist Programmierwissen hilfreich.

Welche Risiken gibt es? – Datenschutz, Halluzinationen, Kosten. Mit Policies, Logging und Quellprüfung reduzierbar.

FAQ‑Markup:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Was ist der Unterschied zwischen Chatbot, Assistent und KI‑Agent*in?",
      "acceptedAnswer": {"@type": "Answer", "text": "Chatbots sind regelbasiert, Assistenten reagieren, Agent*innen handeln mit Planung, Tools und Gedächtnis."}
    },
    {
      "@type": "Question",
      "name": "Brauche ich Programmierwissen?",
      "acceptedAnswer": {"@type": "Answer", "text": "Mit JSON‑Konfigurationen und wenig Code startest du schnell; komplexe Tools erfordern mehr Programmierwissen."}
    },
    {
      "@type": "Question",
      "name": "Welche Risiken gibt es?",
      "acceptedAnswer": {"@type": "Answer", "text": "Datenschutz, Halluzinationen, Kosten; mindere sie mit Policies, Logging und Quellprüfung."}
    }
  ]
}
</script>

---

Hinweis zur KI‑Transparenz

Dieser Beitrag wurde KI‑unterstützt (Agent‑Workflow) erstellt und redaktionell geprüft.