---
title: ""
canonical: "https://studiomeyer.academy/playbooks/agent-tracing-mit-opentelemetry"
language: de
publisher: "StudioMeyer Academy, https://studiomeyer.academy (llms.txt: https://studiomeyer.academy/llms.txt)"
---

[← Alle Playbooks](https://studiomeyer.academy/playbooks)

Playbook· build

# Sehen was Dein Agent wirklich getan hat, Tracing in 10 Schritten mit OpenTelemetry

Ein Agent läuft, macht zwanzig Tool-Calls und liefert am Ende irgendwas. Warum? Mit Tracing machst Du die Blackbox auf und siehst jeden Schritt als Zeitachse. So richtest Du es ein.

Du hast einen Agenten gebaut, er ruft ein paar Tools auf, denkt zwischendrin nach und liefert am Ende ein Ergebnis. Wenn das Ergebnis gut ist, freust Du Dich. Wenn es falsch ist, stehst Du im Dunkeln. Welches Tool hat gefeuert? Was kam zurück? Wo ist die Kette gekippt? Bei einem einzelnen Prompt kannst Du das noch im Log nachlesen. Bei einem Agenten mit zwanzig Schritten über drei MCP-Server hinweg nicht mehr.

Tracing löst genau das. Du machst jeden Schritt sichtbar als einen Eintrag auf einer Zeitachse, mit Dauer, Ein- und Ausgabe, verschachtelt so wie die Aufrufe wirklich passiert sind. Das ist keine exotische Technik, das ist der gleiche Standard mit dem große Web-Systeme seit Jahren beobachtet werden. Und seit die MCP-Spec vom 28. Juli 2026 W3C Trace Context fest verankert hat, reist so ein Trace sauber von Deiner Host-App durch den Client, über den Server bis ins letzte Tool. Ich gehe die zehn Schritte durch die Du brauchst um von blind zu sehend zu kommen.

## Schritt 1, der Unterschied zwischen Logs und Traces

Logs sind Zettel die Du irgendwo hinwirfst. "Tool search aufgerufen." "Antwort erhalten." Jede Zeile steht für sich, keine weiß von der anderen. Bei einem Agenten mit vielen parallelen und verschachtelten Aufrufen wird das schnell zu einem Wust in dem Du nichts mehr zuordnest.

Ein Trace ist eine Zeitachse mit Struktur. Ein Trace umfasst einen kompletten Durchlauf, zum Beispiel eine ganze Agent-Anfrage. Darin sitzen Spans, und jeder Span ist ein einzelner Abschnitt mit Anfang, Ende und Eltern-Span. Der Agent-Lauf ist der äußere Span, jeder Tool-Call ein Kind-Span darin, jeder LLM-Call auch. Am Ende siehst Du einen Baum statt einer Liste, und in dem Baum liest Du sofort ab wo die Zeit hingeht und wo etwas schiefging.

## Schritt 2, das Vokabular das Du wirklich brauchst

Drei Begriffe, mehr nicht für den Anfang. Ein **Trace** ist der gesamte Vorgang und hat eine Trace-ID. Ein **Span** ist ein Abschnitt darin und hat eine eigene Span-ID plus einen Verweis auf seinen Eltern-Span. Ein **Attribut** ist ein Schlüssel-Wert-Paar das Du an einen Span hängst, etwa welches Modell lief oder wie viele Tokens es kostete.

Das reicht um alles andere zu verstehen. OpenTelemetry, kurz OTel, ist der offene Standard der diese drei Dinge definiert. Er ist herstellerneutral, das heißt Du instrumentierst einmal und kannst die Traces später in jedes kompatible Backend schicken ohne Deinen Code anzufassen.

## Schritt 3, warum der Trace über Systemgrenzen hält

Der Trick an OTel ist die Weitergabe der IDs. Wenn Dein Agent einen MCP-Server aufruft, gibt er die Trace-ID mit. Der Server öffnet seinen eigenen Span, hängt ihn als Kind an und gibt die ID an das Tool weiter. So entsteht ein einziger Baum, obwohl drei getrennte Prozesse beteiligt waren.

Der Standard dafür heißt W3C Trace Context. Er transportiert die Information in einem Header namens `traceparent`, dazu kommen `tracestate` und `baggage` für Zusatzinfos. Das Format ist fix, ein Beispiel sieht illustrativ so aus:

```
traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
```

Vier Teile, getrennt durch Bindestriche. Version, dann die Trace-ID, dann die ID des aufrufenden Spans, dann ein Flag ob dieser Trace aufgezeichnet wird. Du musst das nie von Hand bauen, die Bibliothek macht es. Aber es hilft zu wissen dass genau diese Zeichenkette dafür sorgt dass alles zusammenbleibt.

## Schritt 4, was die neue MCP-Spec daran ändert

Bis vor kurzem war die Frage wo diese IDs in einem MCP-Request stehen sollten Auslegungssache. Jeder Server machte es ein bisschen anders, und ein Trace riss oft an der Grenze zwischen Client und Server ab. Die Spec-Version 2026-07-28 räumt das auf. `traceparent`, `tracestate` und `baggage` haben jetzt feste Plätze im `_meta` Feld jedes Requests. Das ist SEP-414.

Für Dich heißt das, wenn Du einen aktuellen MCP-Server oder Client benutzt, wird die Trace-Kontext-Weitergabe entweder schon mitgeliefert oder Du kannst Dich darauf verlassen dass die Key-Namen stimmen. Kein Raten mehr wo die ID hinsoll. Wer die Details der Spec noch nicht kennt, findet sie im Playbook zur [2026-07-28 Spec](https://studiomeyer.academy/playbooks/mcp-spec-2026-07-was-aendert-sich).

## Schritt 5, ein Backend wählen wo die Traces landen

Instrumentieren ist die eine Hälfte, angucken die andere. Du brauchst ein Ziel das die Traces empfängt und als Zeitachse darstellt. Für LLM- und Agent-Anwendungen ist Langfuse eine gute erste Wahl, weil es genau auf diesen Fall zugeschnitten ist. Es zeigt pro Span die Prompts, die Antworten, die Token-Zahlen und die Kosten, nicht nur nackte Zeitbalken.

Langfuse lässt sich selbst hosten und nimmt Traces im OpenTelemetry-Format entgegen. Das ist der Punkt der Dir Freiheit gibt. Du schreibst Deinen Code gegen OTel, und wenn Dir Langfuse später nicht passt, schickst Du die gleichen Traces woanders hin. Alternativen die ebenfalls OTel sprechen sind Jaeger für den rein technischen Blick oder ein gemanagtes Backend wenn Du nichts selbst betreiben willst.

## Schritt 6, den ersten Span von Hand setzen

Fang klein an. Nimm eine einzige Funktion, den äußersten Punkt Deines Agenten, und wickle sie in einen Span. In Python mit dem OTel-SDK sieht das im Kern so aus:

```python
from opentelemetry import trace

tracer = trace.get_tracer("mein-agent")

with tracer.start_as_current_span("agent-run") as span:
    span.set_attribute("agent.task", task_beschreibung)
    ergebnis = agent.run(task_beschreibung)
    span.set_attribute("agent.status", "ok")
```

Das ist der ganze Zauber. `start_as_current_span` öffnet den Span, alles was innerhalb des `with`\-Blocks passiert hängt automatisch darunter, und am Ende schließt er sich. Die Attribute die Du setzt tauchen später im Backend auf und machen den Span lesbar. In TypeScript und anderen Sprachen ist das Muster identisch, nur die Syntax unterscheidet sich.

## Schritt 7, die Tool-Calls einzeln sichtbar machen

Ein Span um den ganzen Lauf zeigt Dir die Gesamtdauer, mehr nicht. Der Wert kommt wenn jeder Tool-Call sein eigener Kind-Span wird. Du legst also um jeden Tool-Aufruf ebenfalls einen Span, mit dem Namen des Tools und den wichtigen Argumenten als Attribute.

```python
with tracer.start_as_current_span("tool-call") as span:
    span.set_attribute("tool.name", tool_name)
    span.set_attribute("tool.args", str(argumente)[:500])
    antwort = tool.call(argumente)
    span.set_attribute("tool.result_len", len(str(antwort)))
```

Ein Detail das Dich sonst beißt. Schneide lange Werte ab, hier auf 500 Zeichen. Wenn Du komplette Tool-Antworten mit zehntausend Zeichen als Attribut speicherst, blähst Du Deine Traces auf und machst das Backend langsam. Der Sinn ist die Struktur zu sehen, nicht jedes Byte zu archivieren.

## Schritt 8, keine Geheimnisse in den Trace schreiben

Das ist die Stelle an der Tracing gefährlich wird wenn Du nicht aufpasst. Ein Trace fängt Ein- und Ausgaben ein, und da stehen schnell Dinge drin die nicht in ein Beobachtungs-Backend gehören. API-Schlüssel in einem Argument. Eine Kundenmail in einer Tool-Antwort. Ein ganzer Prompt mit personenbezogenen Daten.

Bau Dir eine kleine Funktion die vor dem Setzen eines Attributs bekannte Muster ersetzt, Schlüssel, Mailadressen, Tokens. Und überleg bei jedem Attribut ob Du diesen Wert wirklich brauchst um ein Problem zu debuggen. Meistens reicht die Länge oder ein Hash statt des Inhalts. Wer beim Thema Datensparsamkeit tiefer einsteigen will, findet die Grundlagen im Playbook [Datenschutz mit KI-Tools](https://studiomeyer.academy/playbooks/datenschutz-mit-ki-tools).

## Schritt 9, aus dem Trace eine Frage beantworten

Instrumentierung ist Mittel zum Zweck. Der Zweck ist eine konkrete Frage schnell zu beantworten. Drei die immer wieder kommen. Erstens, wo geht die Zeit hin. Du öffnest den langsamsten Lauf und siehst sofort welcher Span den Balken füllt, oft ist es ein einziger Tool-Call der eine externe API blockiert.

Zweitens, wo kippt die Logik. Ein Lauf liefert Unsinn, Du gehst die Kind-Spans der Reihe nach durch und findest die Stelle an der ein Tool schon die falsche Antwort zurückgab, bevor das Modell darauf aufbaute. Drittens, was kostet ein Lauf wirklich. Wenn Du Token-Zahlen als Attribute mitschreibst, summierst Du sie über den Trace und siehst die echten Kosten pro Anfrage statt einer Monatsrechnung ohne Aufschlüsselung. Für die reine Kostenseite lohnt sich zusätzlich das Playbook [Was kostet KI wirklich](https://studiomeyer.academy/playbooks/was-kostet-ki-wirklich).

## Schritt 10, Tracing zur Gewohnheit machen

Ein einmal instrumentierter Agent bringt wenig wenn Du nur draufschaust wenn schon etwas brennt. Der Nutzen kommt aus der Routine. Schau Dir ein paar Traces an nachdem Du eine Änderung deployt hast, nicht erst wenn sich jemand beschwert. Leg Dir zwei, drei Attribute fest die Du bei jedem Agenten mitschreibst, Task, Modell, Status, Token-Zahl, damit Deine Traces vergleichbar bleiben.

Und trenne sauber zwischen Tracing und Evaluierung. Ein Trace sagt Dir was passiert ist, ein Eval sagt Dir ob das Ergebnis gut war. Beides brauchst Du, aber es sind zwei verschiedene Werkzeuge. Wenn Du beim Eval-Teil weitermachen willst, ist das Playbook [Agent-Eval in 60 Minuten](https://studiomeyer.academy/playbooks/agent-eval-in-60-minuten) der passende nächste Schritt.

## Was als nächstes

Wenn Du noch keinen eigenen Agenten laufen hast, an dem sich Tracing lohnt, bau erst einen mit dem [Claude Agent SDK](https://studiomeyer.academy/playbooks/claude-agent-sdk-erster-eigener-agent) und komm dann hierher zurück. Wer schon MCP-Server betreibt und wissen will was die neue Spec sonst noch ändert, liest [MCP wird stateless](https://studiomeyer.academy/playbooks/mcp-spec-2026-07-was-aendert-sich). Und für den großen Bogen über Agent-Qualität gehört [Agent-Eval in 60 Minuten](https://studiomeyer.academy/playbooks/agent-eval-in-60-minuten) als Zwilling neben dieses Playbook.

## Quellen

- W3C Trace Context in der MCP-Spec (SEP-414), offizielle Ankündigung: https://blog.modelcontextprotocol.io/posts/2026-07-28-release-candidate/
- OpenTelemetry Konzepte (Traces, Spans, Context Propagation): https://opentelemetry.io/docs/concepts/
- W3C Trace Context Standard (traceparent Format): https://www.w3.org/TR/trace-context/
- Langfuse, OpenTelemetry-kompatibles Tracing für LLM-Anwendungen: https://langfuse.com/docs

[← Agenten die abdriften stoppen](https://studiomeyer.academy/playbooks/agenten-die-abdriften-stoppen) [Lange Dokumente von KI zusamme →](https://studiomeyer.academy/playbooks/lange-dokumente-sicher-zusammenfassen)

Alle Playbooks

[01. Von ChatGPT zu Claude. Anleitung in 10 Schritten](https://studiomeyer.academy/playbooks/von-chatgpt-zu-claude) [02. Von ChatGPT zu Codex. Anleitung in 10 Schritten](https://studiomeyer.academy/playbooks/von-chatgpt-zu-codex) [03. Dein erster MCP-Server in 90 Minuten](https://studiomeyer.academy/playbooks/erster-mcp-server-in-90-minuten) [04. Memory portabel nutzen, gleiches Gedächtnis in Claude, Codex und Cursor](https://studiomeyer.academy/playbooks/memory-portabel-nutzen) [05. DACH-Legal. EU AI Act und DSGVO für AI-Operator](https://studiomeyer.academy/playbooks/dach-legal-eu-ai-act-und-dsgvo) [06. Dein erster Sub-Agent in 30 Minuten](https://studiomeyer.academy/playbooks/erster-sub-agent-in-30-min) [07. MCP-Server publishen Schritt für Schritt](https://studiomeyer.academy/playbooks/mcp-server-publishen) [08. Hooks gegen Halluzinationen](https://studiomeyer.academy/playbooks/hooks-gegen-halluzinationen) [09. Git für KI, Quickstart in 30 Minuten](https://studiomeyer.academy/playbooks/git-fuer-ki-quickstart) [10. Scheduled Agents mit Claude Code Routines](https://studiomeyer.academy/playbooks/scheduled-agents-mit-routines) [11. Tool-Sprawl vermeiden, von 530 auf 30 MCP-Tools pro Session](https://studiomeyer.academy/playbooks/tool-sprawl-vermeiden) [12. Claude Code Update-Strategie, ohne dass Dein Workflow plotzlich kaputt ist](https://studiomeyer.academy/playbooks/claude-code-update-strategie) [12. Subagent-Team strukturieren, welche sechs Rollen Du im Daily-Driver brauchst](https://studiomeyer.academy/playbooks/subagent-team-strukturieren) [13. Claude Code Cost Controls für Daily Driver, in 10 Schritten unter 30 Dollar pro Tag bleiben](https://studiomeyer.academy/playbooks/claude-code-cost-controls-fuer-daily-driver) [14. Eigene Slash-Commands für Claude Code, in 30 Minuten produktiv](https://studiomeyer.academy/playbooks/eigene-slash-commands-fuer-claude-code) [15. Claude Code headless in CI/CD, ein Setup das morgen schon läuft](https://studiomeyer.academy/playbooks/claude-code-headless-in-ci-cd) [16. Agent-Eval in 60 Minuten, wie Du herausfindest ob Dein Agent gut ist](https://studiomeyer.academy/playbooks/agent-eval-in-60-minuten) [17. Plan Mode in Claude Code, der unsichtbare Sicherheitsgurt, wann Du ihn brauchst und wie Du ihn drin lässt](https://studiomeyer.academy/playbooks/plan-mode-richtig-nutzen) [18. MCP debuggen wenn nichts geht, die 10 Checks die 90 Prozent der Fälle lösen](https://studiomeyer.academy/playbooks/mcp-debuggen-wenn-nichts-geht) [18. Prompt-Caching meistern, in 10 Schritten von Cache-Miss zu 80 Prozent Hit-Rate](https://studiomeyer.academy/playbooks/prompt-caching-meistern) [19. Memory Drift reparieren, wenn das Gedächtnis kippt](https://studiomeyer.academy/playbooks/memory-drift-reparieren) [20. MCP-STDIO-Sicherheit, was die OX-Security-Story für Dich bedeutet](https://studiomeyer.academy/playbooks/mcp-stdio-sicherheit) [21. Opus 4.7 Migration, was sich für API-Builder geändert hat](https://studiomeyer.academy/playbooks/opus-4-7-migration) [22. Erste eigene Skill in 30 Minuten, wenn Slash-Commands nicht mehr reichen](https://studiomeyer.academy/playbooks/erste-eigene-skill-in-30-min) [23. Context-Window managen in langen Claude-Code-Sessions](https://studiomeyer.academy/playbooks/context-window-managen-claude-code) [24. Advisor Tool, Opus als Berater und Sonnet als Executor in einem API-Call](https://studiomeyer.academy/playbooks/advisor-tool-opus-als-berater-sonnet-als-executor) [25. MCP-Server mit OAuth 2.1 absichern, in 60 Minuten produktiv](https://studiomeyer.academy/playbooks/mcp-server-auth-mit-oauth-2-1) [26. Plugin-Bundles per URL teilen, --plugin-url in 30 Minuten](https://studiomeyer.academy/playbooks/plugin-bundle-via-url-distribution) [27. Claude Code im Team, wie ihr CLAUDE.md gemeinsam pflegt ohne dass es zur Mülltonne wird](https://studiomeyer.academy/playbooks/claude-code-im-team-claude-md-gemeinsam-pflegen) [27. Fremde Claude-Code-Plugins aus ZIP und URL laden, sicher in 20 Minuten](https://studiomeyer.academy/playbooks/claude-code-plugins-aus-zip-und-url-laden) [28. Confused-Deputy-Audit für Claude Code, in 25 Minuten durchziehen](https://studiomeyer.academy/playbooks/confused-deputy-audit-fuer-claude-code) [28. Dein erstes Claude Code Plugin in 60 Minuten, vom leeren Folder zum installierbaren Bundle](https://studiomeyer.academy/playbooks/dein-erstes-claude-code-plugin) [29. Pull Request Reviews mit Claude Code, 10 Schritte für den PR-Workflow den keiner mehr blockiert](https://studiomeyer.academy/playbooks/pull-request-reviews-mit-claude-code) [30. Claude Projects für Nicht-Coder, ein produktiver Workspace in 30 Minuten](https://studiomeyer.academy/playbooks/claude-projects-fuer-nicht-coder) [31. Promptbibliothek aufbauen, Lieblings-Prompts wiederverwenden ohne Copy-Paste](https://studiomeyer.academy/playbooks/prompt-bibliothek-aufbauen) [32. Output Styles für Claude Code, in 20 Minuten ein eigener Ton](https://studiomeyer.academy/playbooks/output-styles-fuer-claude-code) [33. Statusline für Claude Code, in 15 Minuten Kontext im Blick](https://studiomeyer.academy/playbooks/statusline-fuer-claude-code) [34. Claude Code Checkpoints und /rewind: dein Sicherheitsnetz für riskante Edits](https://studiomeyer.academy/playbooks/claude-code-checkpoints-und-rewind) [34. Discovery-Files konsistent halten, damit AI-Crawler nicht alte Bullshit-Bios zitieren](https://studiomeyer.academy/playbooks/discovery-files-konsistent-halten) [34. Hooks debuggen wenn nichts feuert](https://studiomeyer.academy/playbooks/hooks-debuggen-wenn-nichts-feuert) [34. Parallele Claude-Code-Sessions mit git worktrees, zwei Branches gleichzeitig ohne Konflikt](https://studiomeyer.academy/playbooks/parallele-claude-sessions-mit-worktrees) [34. Skill triggert nicht, was Du in 10 Schritten prüfst bevor Du wieder /befehl tippst](https://studiomeyer.academy/playbooks/skill-trigger-debugging) [34. Sub-Agent oder Skill oder MCP-Tool, was wählst Du wann](https://studiomeyer.academy/playbooks/sub-agent-oder-skill-oder-mcp-tool) [35. Mit Git Worktrees parallele Claude-Code-Sessions fahren](https://studiomeyer.academy/playbooks/claude-code-mit-git-worktrees) [35. Memory-Backup vor Update, damit Du nach einem Schema-Migrations-Bug nicht weinst](https://studiomeyer.academy/playbooks/memory-backup-vor-update) [36. AGENTS.md neben CLAUDE.md, ein Repo-Kontext für mehrere AI-Tools](https://studiomeyer.academy/playbooks/agents-md-neben-claude-md) [47. Generative Engine Optimization für kleine Sites, damit Perplexity und ChatGPT-Search Dich zitieren](https://studiomeyer.academy/playbooks/geo-fuer-kleine-sites) [50. Opus 4.8 Migration, das erste Opus-Update ohne Breaking Changes](https://studiomeyer.academy/playbooks/opus-4-8-migration) [51. Background-Sessions mit Claude Agents: lange Tasks laufen lassen ohne dein Terminal zu blockieren](https://studiomeyer.academy/playbooks/background-sessions-mit-claude-agents) [52. Claude Code Bash-Sandbox einrichten: Befehle isolieren statt blind freigeben](https://studiomeyer.academy/playbooks/claude-code-bash-sandbox-einrichten) [53. Vom Skript zum eigenen Agent: der Claude Agent SDK in 90 Minuten](https://studiomeyer.academy/playbooks/claude-agent-sdk-erster-eigener-agent) [54. MCP App bauen: interaktive UI in deinem MCP-Tool statt Text-Wand](https://studiomeyer.academy/playbooks/mcp-app-interaktive-ui-bauen) [55. Mythos teure Modellklasse: Wann sich das teuerste KI-Modell wirklich lohnt](https://studiomeyer.academy/playbooks/mythos-klasse-wann-lohnt-sich-das) [56. Fallback-Modelle einrichten, damit Claude Code bei Overload nicht stehenbleibt](https://studiomeyer.academy/playbooks/claude-code-fallback-modelle) [57. Dynamic Workflows in Claude Code, dein erstes orchestriertes Multi-Agent-Skript](https://studiomeyer.academy/playbooks/dynamic-workflows-in-claude-code) [58. Security-Guidance Plugin für Claude Code, automatischer Sicherheits-Review während du baust](https://studiomeyer.academy/playbooks/claude-code-security-guidance-plugin) [59. Claude Code spinnt nach einer Config-Änderung, so findest du die Ursache](https://studiomeyer.academy/playbooks/claude-code-safe-mode-diagnose) [60. MCP ist stateless, was die 2026-07-28 Spec ändert und was Du jetzt tun musst](https://studiomeyer.academy/playbooks/mcp-spec-2026-07-was-aendert-sich) [61. Dein erster echter n8n-Flow, Automatisierung für Leute die nicht programmieren](https://studiomeyer.academy/playbooks/mein-erster-n8n-flow-fuer-nicht-coder) [62. Agentic Payments mit x402, was Du als Builder über maschinen-bezahlte APIs wissen musst](https://studiomeyer.academy/playbooks/agentic-payments-x402) [63. GPT-5.6 oder Opus 5, welches Modell für welche Aufgabe](https://studiomeyer.academy/playbooks/gpt-5-oder-opus-4-8-welches-modell) [64. Subagents die Subagents spawnen, die 5-Ebenen-Regel von Claude Code](https://studiomeyer.academy/playbooks/subagents-die-subagents-spawnen) [65. Claude Code Agent Teams einrichten, mehrere Sessions die sich gegenseitig zuarbeiten](https://studiomeyer.academy/playbooks/claude-code-agent-teams-einrichten) [66. Modell-Verfügbarkeit tracken, wenn ein Modell über Nacht verschwindet](https://studiomeyer.academy/playbooks/modell-verfuegbarkeit-tracken) [67. Datenschutz beim Arbeiten mit KI-Tools: zehn Gewohnheiten, die dich schützen](https://studiomeyer.academy/playbooks/datenschutz-mit-ki-tools) [68. Auto Mode in Claude Code sicher nutzen, in 10 Schritten ohne Selbstmord-Kommandos](https://studiomeyer.academy/playbooks/claude-code-auto-mode-sicher-nutzen) [69. KI für die Jobsuche: In 10 Schritten durch den ATS-Filter](https://studiomeyer.academy/playbooks/ki-fuer-jobsuche) [70. In 10 Schritten ein AI-Portfolio bauen das dir einen Job bringt](https://studiomeyer.academy/playbooks/ai-portfolio-fuer-den-job) [71. AI-Skills im Lebenslauf und Interview glaubwürdig belegen](https://studiomeyer.academy/playbooks/ai-skills-belegen-lebenslauf-interview) [72. Effort-Level in Claude Code, wann low reicht und wann Du max brauchst](https://studiomeyer.academy/playbooks/effort-level-in-claude-code-einstellen) [73. Vom Academy-Skill zum ersten bezahlten KI-Auftrag](https://studiomeyer.academy/playbooks/erster-bezahlter-ki-auftrag) [74. Eine KI-Antwort faktenchecken: 10 Schritte gegen falsche Auskünfte](https://studiomeyer.academy/playbooks/ki-antwort-faktenchecken) [75. KI-Bilder für deine Marke, vom ersten Prompt zum fertigen Set](https://studiomeyer.academy/playbooks/ki-bilder-fuer-deine-marke) [76. KI für Selbstständige, Angebote und Kundenmails in der halben Zeit schreiben](https://studiomeyer.academy/playbooks/ki-fuer-selbststaendige-angebote-und-mails) [77. KI-Inhalte erkennen und richtig kennzeichnen](https://studiomeyer.academy/playbooks/ki-inhalte-erkennen-und-kennzeichnen) [78. KI-Notizen für Meetings, die wirklich brauchbar sind](https://studiomeyer.academy/playbooks/ki-notizen-fuer-meetings) [79. Lokale KI auf dem eigenen Rechner, damit deine Daten nie das Haus verlassen](https://studiomeyer.academy/playbooks/lokale-ki-auf-dem-eigenen-rechner) [80. Die drei MCP-Primitive verstehen, Tools, Resources und Prompts](https://studiomeyer.academy/playbooks/mcp-primitives-tools-resources-prompts) [81. Verlässliches JSON aus jeder AI, damit Deine Automation nicht bricht](https://studiomeyer.academy/playbooks/verlaessliches-json-aus-ai) [82. Was KI-Tools wirklich kosten, und wo die versteckten Rechnungen lauern](https://studiomeyer.academy/playbooks/was-kostet-ki-wirklich) [83. Prompt Injection verstehen, die drei Fallen wenn dein KI-Assistent fremde Texte liest](https://studiomeyer.academy/playbooks/prompt-injection-erkennen) [84. Dich vor KI-Betrug schützen, Fake-Anrufe, Phishing und falsche Job-Angebote](https://studiomeyer.academy/playbooks/dich-vor-ki-betrug-schuetzen) [85. Opus 5 Migration, wenn Denken plötzlich der Standard ist](https://studiomeyer.academy/playbooks/opus-5-migration) [86. Die KI-Richtlinie für kleine Teams, auf einer Seite](https://studiomeyer.academy/playbooks/ki-richtlinie-fuer-kleine-teams) [87. Agenten die abdriften stoppen](https://studiomeyer.academy/playbooks/agenten-die-abdriften-stoppen) [88. Sehen was Dein Agent wirklich getan hat, Tracing in 10 Schritten mit OpenTelemetry](https://studiomeyer.academy/playbooks/agent-tracing-mit-opentelemetry) [89. Lange Dokumente von KI zusammenfassen lassen, ohne dass sie Sachen erfindet](https://studiomeyer.academy/playbooks/lange-dokumente-sicher-zusammenfassen) [90. Fremde MCP-Server sicher prüfen, bevor Du sie installierst](https://studiomeyer.academy/playbooks/fremde-mcp-server-sicher-pruefen) [91. KI als Lern-Coach: ein neues Feld lernen für den Berufswechsel](https://studiomeyer.academy/playbooks/ki-lern-coach-berufswechsel) [92. Berufsbild AI-Operator: was macht man da eigentlich?](https://studiomeyer.academy/playbooks/berufsbild-ai-operator) [93. KI nutzen ohne selbst zu verlernen](https://studiomeyer.academy/playbooks/ki-nutzen-ohne-selbst-zu-verlernen) [94. Warum dein Screenshot schrumpft, und wie du das steuerst](https://studiomeyer.academy/playbooks/bilder-und-screenshots-an-die-ki-geben) [95. Einen Deep-Research-Auftrag formulieren, damit der Bericht auch was taugt](https://studiomeyer.academy/playbooks/deep-research-auftrag-formulieren) [96. Zahlen und Tabellen mit KI auswerten, ohne dass am Ende Unsinn rauskommt](https://studiomeyer.academy/playbooks/zahlen-und-tabellen-mit-ki-auswerten) [97. KI-Benchmarks lesen ohne dich verarschen zu lassen](https://studiomeyer.academy/playbooks/ki-benchmarks-richtig-lesen) [98. KI als Sparringspartner, bessere Entscheidungen statt netter Zustimmung](https://studiomeyer.academy/playbooks/ki-als-sparringspartner-fuer-entscheidungen) [99. Mit KI eine neue Fähigkeit lernen, der ehrliche Weg](https://studiomeyer.academy/playbooks/mit-ki-neue-faehigkeit-lernen) [100. Deinen MCP-Server ändern ohne die Nutzer zu brechen](https://studiomeyer.academy/playbooks/mcp-server-aendern-ohne-nutzer-zu-brechen) [101. Dein erstes lokales KI-Modell in 30 Minuten](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten) [102. Welches lokale Modell zu Deiner Hardware passt](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware) [103. Lokale KI und die DSGVO, was sie wirklich löst und was nicht](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) [104. MCP mit lokalen Modellen, Werkzeuge ohne Cloud](https://studiomeyer.academy/playbooks/mcp-mit-lokalen-modellen) [105. Lokal oder Cloud, die ehrliche Rechnung](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung) [106. Wenn ein fremdes Repo Deine KI konfiguriert. Der ChainDrop-Fall](https://studiomeyer.academy/playbooks/agent-konfiguration-als-angriffsweg) [107. Gespräche offline transkribieren, ohne dass sie das Haus verlassen](https://studiomeyer.academy/playbooks/gespraeche-offline-transkribieren) [108. n8n mit einem lokalen Modell verbinden](https://studiomeyer.academy/playbooks/n8n-mit-lokalem-modell-verbinden) [109. Dokumente offline auslesen, wenn der Scan nicht hochgeladen werden darf](https://studiomeyer.academy/playbooks/dokumente-offline-auslesen) [→ Zur Academy](https://studiomeyer.academy/levels/1)

## Sitemap

Öffentliche Seiten dieser Website als Markdown: [Sitemap](https://studiomeyer.academy/sitemap.md). Kuratierter Einstieg: [llms.txt](https://studiomeyer.academy/llms.txt), Volltext: [llms-full.txt](https://studiomeyer.academy/llms-full.txt).