Technische Grundlagen: Agentic Coding

Was es ist: Ein laufendes Programm auf deinem Computer. Wenn du Chrome oeffnest, startet ein Prozess. Wenn du ein Terminal oeffnest, startet ein anderer.

Warum es wichtig ist: Ein Coding Agent ist am Ende ein Prozess. Er laeuft als Programm auf einem Computer -- nicht mehr, nicht weniger.

Technisch: Jeder Prozess hat:

• Einen eigenen Speicherbereich (andere Prozesse koennen nicht reinschauen)
• Eine Prozess-ID (PID) zur Identifikation
• Einen Parent-Prozess (wer hat ihn gestartet?)
• Zugriff auf Ressourcen (Dateien, Netzwerk, CPU)

Was es ist: Jeder Prozess hat drei "Kanaele" fuer Kommunikation:

Warum es wichtig ist: Wenn ein Agent ein CLI-Tool ausfuehrt, liest er das Ergebnis aus stdout. Wenn etwas schiefgeht, kommt die Fehlermeldung ueber stderr. Die gesamte Agent-Tool-Kommunikation laeuft ueber diese Streams.

Pipe (|): Verbindet stdout eines Programms mit stdin eines anderen. Das ist die Unix-Philosophie: kleine Programme, die zusammenarbeiten.

Multiplexer (Mux): Mehrere Eingangssignale werden in EINEN Kanal zusammengefuehrt.

Demultiplexer (Demux): EIN Signal wird auf mehrere Ausgangskanaele verteilt.

Im Agent-Kontext: Wenn ein Agent eine Nachricht vom LLM bekommt, muss er entscheiden: Ist das Text fuer den User? Ist das ein Tool-Call? Ist das ein Steuerbefehl? Das ist Demultiplexing -- ein Datenstrom wird auf verschiedene Handler verteilt.

Tmux (Terminal Multiplexer): Ein Programm das mehrere Terminal-Sessions in einem Fenster verwaltet -- auch ein Multiplexer, diesmal fuer Terminal-Streams.

Was es ist: Ein Programm, das ueber Text-Befehle im Terminal gesteuert wird -- im Gegensatz zu einer grafischen Oberflaeche (GUI).

# GUI: Du klickst auf "Datei > Speichern"
# CLI: Du tippst:
cp dokument.txt backup/dokument.txt

Die Erkenntnis: LLMs sind extrem gut darin, CLI-Befehle zu schreiben und deren Ausgabe zu verstehen. Das ist billiger und zuverlaessiger als komplexe API-Protokolle.

Was es ist: Ein Protokoll, um sich sicher und verschluesselt mit einem entfernten Computer zu verbinden und dort Befehle auszufuehren.

iPhone (SSH-Client)  ───verschluesselt───>  Server auf Fly.io
                                             |
                                             py laeuft hier
                                             |
                                             Zugriff auf GitHub, Tools, etc.

Drei Datenformate die ueberall vorkommen:

JSON (JavaScript Object Notation): Strukturierte Daten, maschinenlesbar.

{
  "kunde": "Mueller GmbH",
  "betrag": 7100,
  "positionen": [
    {"name": "Beratung", "preis": 3600},
    {"name": "Setup", "preis": 3500}
  ]
}

YAML (YAML Ain't Markup Language): Wie JSON, aber menschenlesbarer. Wird oft fuer Konfiguration verwendet.

kunde: Mueller GmbH
betrag: 7100
positionen:
  - name: Beratung
    preis: 3600
  - name: Setup
    preis: 3500

Markdown: Einfache Textformatierung. DAS zentrale Format fuer Agents.

# Ueberschrift
**fett**, *kursiv*
- Liste
- Punkte

| Tabelle | Spalte |
|---------|--------|
| Wert    | Wert   |

Was es ist: Ein neuronales Netzwerk, das auf riesigen Textmengen trainiert wurde und Text generieren kann. "Large" bezieht sich auf die Anzahl der Parameter (Gewichte im Netzwerk).

Wie es funktioniert (vereinfacht):

1. Text wird in Tokens zerlegt (siehe unten)
2. Tokens gehen durch das neuronale Netzwerk
3. Das Netzwerk berechnet fuer JEDES moegliche naechste Token eine Wahrscheinlichkeit
4. Das wahrscheinlichste Token (oder ein zufaellig gewaehltes aus den Top-Kandidaten) wird ausgegeben
5. Dieses neue Token wird an den bisherigen Text angehaengt
6. Zurueck zu Schritt 2 -- bis ein Stop-Signal kommt

Was es ist: Die kleinste Einheit, in der ein LLM Text verarbeitet. NICHT identisch mit einem Wort.

Faustregel: 1 Token ≈ 4 Zeichen im Englischen, ≈ 3 Zeichen im Deutschen (deutsche Woerter sind laenger).

"Hallo Welt"     = 2 Tokens:  ["Hallo", " Welt"]
"Auftragsverarbeitung" = 4 Tokens: ["Auf", "trags", "ver", "arbeitung"]
"Hello World"    = 2 Tokens:  ["Hello", " World"]

Warum es wichtig ist: Alles wird in Tokens gemessen und abgerechnet:

• Context Window = maximale Tokens die das Modell auf einmal sehen kann
• Kosten = Preis pro 1.000 oder 1.000.000 Tokens
• Wichtig zu wissen: Agent-Loops sind "token-intensive" weil bei JEDEM Schritt der gesamte Kontext gesendet wird

Was es ist: Die maximale Menge an Text (gemessen in Tokens), die ein LLM gleichzeitig "sehen" und verarbeiten kann. Stell dir ein Fenster vor, durch das das Modell auf den Text schaut -- was ausserhalb des Fensters liegt, existiert fuer das Modell nicht.

LLMs werden schlechter, je voller das Context Window ist, weil:

1. Attention-Mechanismus wird ungenauer bei langen Sequenzen
2. "Lost in the middle" -- Informationen in der Mitte werden schlechter erinnert als am Anfang oder Ende
3. Rechenaufwand steigt quadratisch mit der Laenge (bei Standard-Attention)

Was es ist: Eine mathematische Technik, die dem LLM sagt, WO sich jedes Token im Text befindet. Ohne Positionsinformation wuesste das Modell nicht, ob ein Wort am Anfang oder am Ende steht.

Das Problem: Ein neuronales Netzwerk verarbeitet alle Tokens parallel (nicht sequentiell wie ein Mensch liest). Deshalb braucht es eine kuenstliche Positionscodierung.

Wie RoPE funktioniert (vereinfacht):

• Jede Position im Text wird als Rotation in einem hochdimensionalen Raum codiert
• Token an Position 1 bekommt eine bestimmte "Drehung"
• Token an Position 2 bekommt eine andere "Drehung"
• Der Abstand zwischen zwei Tokens ergibt sich aus der Differenz ihrer Rotationen
• Das Modell lernt: "Tokens die nah beieinander sind, gehoeren wahrscheinlich zusammen"

Warum es wichtig ist:

• RoPE ermoeglicht "Context Window Extension" -- laengere Texte verarbeiten als das Training vorgesehen hat
• Techniken wie YaRN oder NTK-aware Scaling strecken die Rotationen, um laengere Kontexte zu unterstuetzen
• Das ist der Grund, warum Modelle heute 128K+ Tokens verarbeiten koennen, obwohl sie mit kuerzerem Kontext trainiert wurden

Was es ist: Wenn das Context Window volllaeuft, muss der Agent entscheiden: Was behalte ich, was werfe ich raus?

Techniken:

1. Summarization: Aeltere Nachrichten werden zusammengefasst ("Die letzten 50 Nachrichten haben ergeben: X")
2. Pruning: Unwichtige Teile werden entfernt (z.B. fehlgeschlagene Tool-Calls)
3. Sliding Window: Nur die letzten N Nachrichten werden behalten
4. Hierarchisch: Alte Nachrichten → Zusammenfassung → nur Zusammenfassung bleibt

Context Window (vereinfacht):

VOR Compaction:
[System Prompt | Msg 1 | Msg 2 | ... | Msg 47 | Msg 48 | Msg 49 | Msg 50]
 ↑ bleibt       ↑ werden zusammengefasst                 ↑ bleiben komplett

NACH Compaction:
[System Prompt | Zusammenfassung von Msg 1-40 | Msg 41-50 (komplett)]

Was es ist: Der Vorgang, ein trainiertes LLM auszufuehren -- also Text zu generieren. Im Gegensatz zu "Training" (wo das Modell lernt) ist Inference die "Nutzung" des fertigen Modells.

Training:   Daten → Modell lernt → fertige Gewichte (einmalig, sehr teuer)
Inference:  Prompt → fertige Gewichte → Antwort (jedes Mal, relativ billig)

Wo Inference laeuft:

• Cloud/API: Anthropic, OpenAI, Google fuehren Inference auf ihren Servern aus
• Lokal: Ollama oder vLLM laden das Modell auf deinen Computer und fuehren Inference dort aus

Ollama: Eine einfache Software, die LLMs lokal auf deinem Computer ausfuehrt. "Docker fuer LLMs."

ollama run llama3.1      # Startet Llama 3.1 lokal
ollama run qwen2.5:14b   # Startet Qwen 2.5 mit 14B Parametern

vLLM: Eine leistungsstaerkere Alternative zu Ollama, optimiert fuer Produktions-Workloads und mehrere gleichzeitige Nutzer. Nutzt fortgeschrittene Techniken wie "PagedAttention" fuer effizientere Speichernutzung.

Warum lokal wichtig ist (DSGVO): Wenn Inference lokal laeuft, verlassen keine Daten den Rechner. Kein Cloud-Provider sieht die Firmendaten.

Was es ist: Eine mathematische Darstellung von Text als Zahlenvektor (eine Liste von Zahlen). Aehnliche Texte haben aehnliche Vektoren.

"Hund"  → [0.21, -0.45, 0.78, 0.12, ...]  (z.B. 768 Zahlen)
"Katze" → [0.19, -0.42, 0.75, 0.15, ...]  (aehnlich! Beides Tiere)
"Auto"  → [-0.61, 0.33, -0.12, 0.89, ...]  (ganz anders)

Wofuer: Semantische Suche. Statt nur nach exakten Woertern zu suchen, kann man nach BEDEUTUNG suchen. "Wie kuendige ich einen Vertrag?" findet auch Dokumente ueber "Vertragsbeendigung" oder "Kuendigungsfristen".

Was es ist: Eine Technik, bei der ein LLM mit externem Wissen angereichert wird, BEVOR es antwortet.

Definition (aus dem Webinar): Ein Agent ist ein LLM mit Zugriff auf ein Dateisystem und eine Command-Line Runtime (wie bash). Er operiert in einem "glorified while loop".

Noch einfacher: Ein Agent ist ein Programm, das:

1. Eine Aufgabe bekommt
2. Nachdenkt (LLM)
3. Etwas tut (Tool ausfuehren)
4. Das Ergebnis prueft
5. Zurueck zu 2, bis die Aufgabe erledigt ist

Was es ist: Der Kern jedes Coding Agents. Ein While-Loop der so lange laeuft, bis die Aufgabe erledigt ist.

Pseudocode:

def agent_loop(aufgabe):
    nachrichten = [system_prompt, aufgabe]

    while True:
        # 1. Kontext sammeln + 2. LLM aufrufen
        antwort = llm.chat(nachrichten)

        # 3. Antwort verarbeiten (Demux)
        if antwort.hat_tool_call():
            # Tool ausfuehren
            ergebnis = tool_executor(antwort.tool_call)
            nachrichten.append(antwort)
            nachrichten.append(ergebnis)
            # 4. Weiter im Loop

        elif antwort.ist_fertig():
            # Aufgabe erledigt
            return antwort.text

        else:
            # Nur Text-Ausgabe
            zeige_user(antwort.text)
            nachrichten.append(antwort)

Was es ist: Die Ausfuehrungsumgebung, in der der Agent laeuft. Wie eine "Buehne" auf der der Agent "auftritt".

Die Agent Runtime stellt bereit:

• Den Loop selbst (die While-Schleife)
• Zugang zum LLM (API-Calls oder lokales Modell)
• Tool-Ausfuehrung (bash, Dateisystem, CLI-Tools)
• Speicher (Nachrichten-Historie, Dateien)
• I/O (Kommunikation mit dem User)

Im py-Kontext: py ist eine Agent Runtime. Claude Code ist eine andere. OpenClaw nutzt py als seine Runtime.

Was es ist: Praktisch synonym mit "Agent Runtime", aber mit einer Nuance: Ein Harness betont den Aspekt des "Einspannens" -- das LLM wird in einen kontrollierten Rahmen eingespannt, der bestimmt, was es tun darf und wie.

Harness = Runtime + Regeln + Grenzen:

• Runtime: "Wo und wie laeuft der Agent?"
• Harness: "Innerhalb welcher Grenzen darf er operieren?"

Was es ist: Die erste Nachricht an das LLM, die seine Rolle, Regeln und Faehigkeiten definiert. Der User sieht den System Prompt normalerweise nicht.

System Prompt (unsichtbar fuer User):
"Du bist ein Vertriebs-Assistent. Du hast folgende Tools: [...]
 Du darfst nie Rabatte geben ohne Freigabe."

User-Nachricht: "Erstelle ein Angebot fuer Mueller GmbH"

→ Das LLM beruecksichtigt BEIDE Teile bei seiner Antwort.

Im Agent-Kontext: Der System Prompt ist quasi die "DNA" des Agents. Er definiert:

• Wer der Agent ist (Rolle)
• Was er kann (Tools-Liste)
• Was er nicht darf (Regeln)
• Wie er antworten soll (Ton, Sprache)

In py: Das Equivalent ist die agent-instructions.md Datei -- Markdown, das beim Start geladen wird.

Stateless: Das LLM hat KEIN Gedaechtnis zwischen Aufrufen. Bei jedem API-Call muss die komplette Konversationshistorie mitgesendet werden.

Das bedeutet: Die Agent Runtime muss den gesamten Zustand verwalten und bei jedem LLM-Call mitsenden. Das LLM selbst "erinnert" sich an nichts.

Was es ist: Ein Programmier-Pattern, bei dem ein Programm kontinuierlich auf Ereignisse (Events) wartet und sie verarbeitet.

while true:
    event = warte_auf_naechstes_event()

    if event.typ == "user_nachricht":
        verarbeite_nachricht(event)
    elif event.typ == "tool_ergebnis":
        verarbeite_tool_ergebnis(event)
    elif event.typ == "timeout":
        behandle_timeout(event)

Der Unterschied zum Agent Loop: Der Agent Loop ist ein spezifischer Event Loop, der auf LLM-Antworten reagiert. Ein Event Loop ist das allgemeinere Konzept.

Was es ist: Ein definierter Weg, wie ein Programm mit einem anderen Programm kommuniziert. Wie ein Kellner im Restaurant -- du (Programm A) sagst dem Kellner (API) was du willst, und er bringt es aus der Kueche (Programm B).

Du (Client)  ──Bestellung──>  Kellner (API)  ──Weiterleitung──>  Kueche (Server)
                              <──Essen────────                  <──Zubereitung──

Typen die im Webinar vorkommen:

HTTP (HyperText Transfer Protocol): Das Protokoll des Webs. Jede Webseite, jede API-Anfrage nutzt HTTP.

REST: Ein Architekturstil fuer APIs, der HTTP-Methoden nutzt.

Was es ist: Eine Bibliothek die die API-Aufrufe vereinfacht. Statt rohe HTTP-Requests zu schreiben, nutzt du fertige Funktionen.

# OHNE SDK (roher HTTP-Request):
import requests
response = requests.post("https://api.anthropic.com/v1/messages",
    headers={"x-api-key": key, "content-type": "application/json"},
    json={"model": "claude-sonnet-4-20250514", "messages": [{"role": "user", "content": "Hallo"}]})

# MIT SDK (eine Zeile):
from anthropic import Anthropic
message = Anthropic().messages.create(model="claude-sonnet-4-20250514",
    messages=[{"role": "user", "content": "Hallo"}])

Was es ist: Ein offener Standard (von Anthropic) der definiert, wie LLMs mit externen Tools kommunizieren. Denk an USB-C fuer AI-Tools.

Wann MCP trotzdem sinnvoll ist:

• Tool-Discovery (Agent kann verfuegbare Tools automatisch entdecken)
• Komplexe Interaktionen die Zustand brauchen (z.B. Datenbank-Session)
• Standard-Integration in verschiedene AI-Produkte

Was es ist: Eine persistente, bidirektionale Verbindung zwischen Client und Server. Im Gegensatz zu HTTP (Frage-Antwort) bleibt die Leitung offen.

Im Agent-Kontext: WebSockets werden fuer Streaming genutzt. Wenn Claude dir Wort fuer Wort antwortet, nutzt das im Hintergrund oft eine persistente Verbindung.

Was es ist: Eine Einweg-Streaming-Verbindung vom Server zum Client. Einfacher als WebSocket, aber nur in eine Richtung.

WebSocket:  Client ←→ Server  (bidirektional)
SSE:        Client ←── Server  (nur Server sendet)

Im Agent-Kontext: Die Anthropic API nutzt SSE fuer Streaming-Responses. Jedes Token wird als separates Event geschickt:

event: content_block_delta
data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"Hallo"}}

event: content_block_delta
data: {"type":"content_block_delta","delta":{"type":"text_delta","text":" Welt"}}

Das Problem: Ein Agent fuehrt Code aus. Dieser Code kann ALLES tun -- Dateien loeschen, Netzwerk-Requests machen, System-Einstellungen aendern. Ohne Isolation ist das wie ein neuer Mitarbeiter mit Admin-Rechten am ersten Tag.

Was es ist: Ein Container ist eine leichtgewichtige, isolierte Umgebung die alles enthaelt was eine Anwendung braucht (Code, Bibliotheken, Einstellungen). Docker ist das bekannteste Tool dafuer.

Analogie: Ein Container ist wie ein Umzugskarton mit Aufschrift. Alles was reingehoert ist drin, nichts anderes. Du kannst den Karton ueberall hinstellen und er funktioniert.

# Dockerfile fuer einen Agent
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "agent.py"]

Was es ist: Ein Tool um mehrere Container gleichzeitig zu starten und zu verbinden. Eine YAML-Datei beschreibt das gesamte Setup.

# docker-compose.yml
services:
  agent:
    build: .
    ports: ["3000:3000"]
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    volumes:
      - ./workspace:/app/workspace
    depends_on: [postgres]

  postgres:
    image: pgvector/pgvector:pg16
    environment:
      - POSTGRES_DB=agent
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Was es ist: Eine komplett simulierte Computer-Hardware. Hat eigenen Kernel, eigenes Betriebssystem, eigenen Speicher. Maximale Isolation.

Nachteil: Schwer, langsam zu starten (Minuten), viel Speicher (GBs). Fuer Agents oft Overkill.

Was es ist: Von Amazon entwickelte MicroVMs. Kombiniert VM-Sicherheit mit Container-Geschwindigkeit.

Was es ist: Ein allgemeiner Begriff fuer eine isolierte Ausfuehrungsumgebung. Wie ein Sandkasten fuer Kinder -- man kann darin spielen, aber der Sand bleibt im Kasten.

Im Agent-Kontext: Jeder gute Agent laeuft in einer Sandbox. Die konkreten Technologien dahinter koennen Firecracker oder andere Isolation-Mechanismen sein.

Was es ist: Punkte im Lebenszyklus des Agents, an denen du eigenen Code einhaengen kannst. Wie Event-Listener in JavaScript oder Middleware in Express.

Was es ist: Vordefinierte Faehigkeiten die der Agent per Slash-Command aktivieren kann. Wie Makros oder Shortcuts -- ein Befehl loest eine komplexe Aktion aus.

/review      → Code-Review mit Checkliste durchfuehren
/test        → Tests schreiben und ausfuehren
/deploy      → Build + Test + Deploy Pipeline
/refactor    → Systematisches Refactoring mit Sicherheitsnetz

Wie Skills funktionieren:

1. Ein Skill ist eine Markdown-Datei mit Anweisungen
2. Wenn der User /skill-name tippt, wird diese Datei als System-Prompt geladen
3. Der Agent folgt den Anweisungen im Skill
4. Das ist wie ein "Modus-Wechsel" -- der Agent wird zum Spezialisten

Was es ist: Die hierarchische Struktur wie Agents Konversationen und Sub-Tasks organisieren. Nicht eine lange Chat-History, sondern ein Baum aus Sessions.

Warum ein Baum? Jeder Sub-Agent hat seinen eigenen Context Window. Das Main-Agent muss nicht alle Details kennen -- nur die Ergebnisse. Das spart Tokens und erlaubt Parallelitaet.

Was es ist: Software die sich selbst anpassen kann -- der Agent aendert den Code waehrend der Ausfuehrung basierend auf dem was gebraucht wird.

Beispiel: User fragt "Analysiere diese CSV-Datei". Statt ein vorgefertigtes CSV-Tool:

1. Agent liest die CSV-Datei
2. Agent schreibt ein Python-Script das genau diese Analyse macht
3. Agent fuehrt das Script aus
4. Agent liest das Ergebnis und antwortet

Das Script existierte vorher nicht und wird vielleicht nie wieder gebraucht -- aber es war perfekt fuer diesen einen Moment.

Was es ist: Ein Architektur-Muster bei dem der User seinen eigenen API-Key mitbringt statt den des Service-Anbieters zu nutzen.