Code-Ausführung mit MCP: Die Revolution der KI-gesteuerten Entwicklung

Die Art und Weise, wie KI-Assistenten mit externen Systemen interagieren, hat sich grundlegend gewandelt. Was vor wenigen Jahren noch utopisch erschien – KI-Agenten, die eigenständig komplexe Entwicklungsaufgaben lösen – ist heute Realität. Der Schlüssel zu dieser Transformation liegt im Model Context Protocol (MCP) von Anthropic und insbesondere in seiner neuesten Innovation: der Code-Ausführung.

Das Skalierungsproblem traditioneller KI-Agenten

Wer bereits mit KI-Agenten gearbeitet hat, kennt das Problem: Je mehr Tools ein Agent zur Verfügung hat, desto mehr Token werden verbraucht – und zwar nicht nur für die tatsächliche Arbeit, sondern bereits für das bloße Vorhandensein der Tool-Definitionen im Kontext. Das Model Context Protocol (MCP) ist ein offener Standard zum Verbinden von KI-Agenten mit externen Systemen, der eine universelle Schnittstelle bietet und es ermöglicht, dass Entwickler MCP einmal implementieren und damit ein ganzes Ökosystem von Integrationen freischalten.¹

Seit der Einführung von MCP im November 2024 hat die Community Tausende von MCP-Servern entwickelt, und die Industrie hat MCP als De-facto-Standard für die Verbindung von Agenten mit Tools und Daten übernommen.¹ Doch mit dieser rasanten Adoption kam ein neues Problem: Wenn zu viele MCP-Server verbunden sind, können Tool-Definitionen und Ergebnisse übermäßig viele Token verbrauchen, was die Effizienz der Agenten reduziert.¹

Die zwei Hauptprobleme

Die meisten MCP-Clients laden alle Tool-Definitionen vorab direkt in den Kontext und machen sie dem Modell über eine direkte Tool-Calling-Syntax zugänglich.¹ Dies führt zu zwei kritischen Herausforderungen:

1. Massive Token-Kosten: Jede Tool-Definition mit ihren Schema-Informationen und Metadaten belegt wertvollen Platz im Kontext-Fenster¹
2. Zwischenergebnisse fressen Tokens: Wenn mehrere Tools verkettet werden, müssen ihre Antworten durch den Kontext des Modells geleitet werden¹

Ein Workflow, der zuvor etwa 150.000 Token verbrauchte, als Tools und Zwischendaten direkt durch das Modell geleitet wurden, wurde mit Code-Ausführung und dateisystembasierten MCP-APIs neu implementiert und nutzte nur noch etwa 2.000 Token – eine Reduktion von 98,7 Prozent.²

Code-Ausführung: Der paradigmatische Wandel

Die Lösung von Anthropic ist elegant und gleichzeitig radikal: Anstatt das Modell Tools direkt aufrufen zu lassen, stellt der MCP-Client jeden Server als einen Satz von Code-Modulen in einem Dateisystem dar. Das Modell schreibt TypeScript-Code, der diese Module importiert und komponiert, und dieser Code läuft in einer Sandbox-Umgebung.¹

Wie funktioniert das konkret?

Der MCP-Client generiert ein Verzeichnis wie „servers“, das die verfügbaren MCP-Server und Tools widerspiegelt. Für jedes MCP-Tool erstellt er eine dünne Wrapper-Funktion, die in einer Quelldatei implementiert ist, zum Beispiel servers/google-drive/getDocument.ts, die intern das MCP-Tool mit typisierten Parametern aufruft.²

Stellen wir uns ein praktisches Beispiel vor: Ein Agent soll Daten aus einem Google Sheet extrahieren und an Salesforce übermitteln. Im traditionellen Ansatz würde das so aussehen:

// Traditioneller Ansatz - ALLES im Kontext
Tool: gdrive.getDocument
Description: Retrieves a document from Google Drive
Parameters: documentId (required, string)
Returns: Komplettes Dokument-Objekt...

Tool: salesforce.updateRecord
Description: Updates a record in Salesforce
Parameters: objectType, recordId, data...
Returns: Vollständiges Update-Resultat...

Mit Code-Ausführung wird daraus:

// Code-basierter Ansatz - On-Demand-Laden
import { getDocument } from './servers/google-drive/getDocument';
import { updateRecord } from './servers/salesforce/updateRecord';

// Nur relevante Daten laden und verarbeiten
const data = await getDocument({ documentId: 'abc123' });
const filteredData = data.rows.filter(r => r.status === 'new');
await updateRecord({ 
  objectType: 'Lead', 
  recordId: 'xyz789',
  data: filteredData 
});

Die konkreten Vorteile

1. Progressive Tool-Entdeckung

Der Agent benötigt nicht alle Tool-Definitionen im Kontext. Er kann das generierte Dateisystem erkunden, verfügbare Server auflisten und spezifische Tool-Module nur bei Bedarf lesen.¹

Modelle sind hervorragend darin, in Dateisystemen zu navigieren. Die Darstellung von Tools als Code in einem Dateisystem ermöglicht es Modellen, Tool-Definitionen bei Bedarf zu lesen, anstatt sie alle im Voraus zu laden.¹

Ein praktisches Beispiel: Beim Arbeiten mit einem hypothetischen Salesforce-Server sucht der Agent nach „salesforce“ und lädt nur die Tools, die er für die aktuelle Aufgabe benötigt.¹

2. Kontexteffiziente Datenverarbeitung

Stellen Sie sich vor, Sie müssen 10.000 Zeilen aus einem Google Sheet verarbeiten. Im traditionellen Ansatz würden all diese Daten durch den Kontext des Modells geleitet. Durch Code-Ausführung kann der Agent die Daten zunächst filtern und nur eine kleine Anzahl von Ergebnissen zurückgeben, anstatt alle Daten in den Kontext zu laden.¹

3. State Management und wiederverwendbare Skills

Das Dateisystem ermöglicht es Agenten, Zwischendateien und wiederverwendbare Skripte zu speichern. Ein Hilfsskript, das eine Tabelle in einen Bericht umwandelt, kann in einem „skills“-Verzeichnis gespeichert und in späteren Sitzungen importiert werden.¹

Praktische Implementierung mit Playwright MCP

Ein hervorragendes Beispiel für die Kraft von MCP ist der Playwright MCP Server. Der Playwright Model Context Protocol Server ist eine leistungsstarke Lösung für die Automatisierung von Browser- und API-Tests mit Playwright und ermöglicht es LLMs, mit Webseiten zu interagieren, Screenshots zu machen, Testcode zu generieren, Webseiten zu scrapen und JavaScript in einer echten Browser-Umgebung auszuführen.⁶

Installation und Konfiguration

Die Installation ist denkbar einfach:

npm install -g @executeautomation/playwright-mcp-server

Für Claude Desktop sieht die Konfiguration so aus:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@executeautomation/playwright-mcp-server"]
    }
  }
}

Praktisches Beispiel: Automatisierte Web-Tests

Mit der Playwright-Integration kann Claude nun komplexe Browser-Automatisierungen durchführen – und das alles in natürlicher Sprache:

User: "Navigiere zu meiner Website, fülle das Kontaktformular aus 
und mache einen Screenshot"

Claude generiert und führt aus:
import { navigate, fill, screenshot } from './servers/playwright';

await navigate({ url: 'https://example.com/contact' });
await fill({ selector: '#name', value: 'Max Mustermann' });
await fill({ selector: '#email', value: 'max@example.com' });
await screenshot({ path: 'contact-form.png' });

Die Herausforderungen und der Preis der Effizienz

Die Ausführung von durch Agenten generiertem Code erfordert eine sichere Ausführungsumgebung mit angemessenem Sandboxing, Ressourcenlimits und Monitoring. Diese Infrastrukturanforderungen fügen operativen Overhead und Sicherheitsüberlegungen hinzu, die direkte Tool-Aufrufe vermeiden.¹

Das Sichern, Überwachen und Verwalten dieser Sandboxes in großem Maßstab ist eine bedeutende Platform-Engineering-Herausforderung, für die die meisten Teams noch nicht gerüstet sind – und hier beginnt die eigentliche Arbeit.⁵

Sicherheitsaspekte

Eine Schwachstelle oder eine geschickt konstruierte Prompt-Injection könnte zu Sandbox-Ausbrüchen, Ressourcenerschöpfungsangriffen oder unautorisiertem Datenzugriff führen. Jede Komponente mit Ausführungsfähigkeiten wird zu einem Angriffsziel.⁵

Für Unternehmen bedeutet die Bereitstellung dieses Patterns:⁵

• Aufbau kritischer Infrastruktur mit rigorosem Threat Modeling
• Observability mit Tools wie OpenTelemetry
• Strikte SRE-geführte Operational Runbooks

Die Zukunft: Code-First Agents

Anthropics Push für Code-Ausführung signalisiert das formale Ende der „Agent-as-a-Prompt“-Ära. Wir erleben die Reifung von KI-Agenten zu vollwertigen Software-Komponenten, die ihre eigenen dedizierten Runtimes, Sicherheitsmodelle und operativen Lebenszyklen erfordern.⁵

Die Wettbewerbslandschaft dreht sich nicht mehr nur darum, wer das intelligenteste Modell hat, sondern wer das sicherste und effizienteste „Betriebssystem“ für die Ausführung von Agenten bereitstellen kann.⁵

Best Practices für die Implementierung

1. Start klein, skaliere intelligent

Beginnen Sie nicht sofort mit Hunderten von Tools. Starten Sie mit 5-10 wesentlichen Integrationen und fügen Sie schrittweise weitere hinzu.

2. Implementieren Sie robustes Monitoring

// Beispiel für Logging in der Code-Ausführung
import { logger } from './utils/monitoring';

export async function executeWithLogging(fn: Function, context: string) {
  const startTime = Date.now();
  try {
    const result = await fn();
    logger.info(`${context} completed in ${Date.now() - startTime}ms`);
    return result;
  } catch (error) {
    logger.error(`${context} failed:`, error);
    throw error;
  }
}

3. Nutzen Sie das Skills-System

Erstellen Sie ein zentrales Repository für häufig verwendete Operationen:

// skills/data-processing/filterAndTransform.ts
export function filterAndTransform(data: any[], criteria: any) {
  return data
    .filter(item => matchesCriteria(item, criteria))
    .map(item => transformItem(item));
}

4. Sandbox-Security von Anfang an

• Verwenden Sie Container-basierte Isolation (Docker, gVisor)
• Implementieren Sie strikte Ressourcenlimits
• Loggen Sie alle Code-Ausführungen für Audit-Zwecke

Integration in moderne Development-Workflows

Als Web-Entwickler mit Fokus auf React, Next.js und FastAPI ergeben sich spannende Möglichkeiten:

Next.js + MCP Integration

// app/api/mcp-agent/route.ts
import { MCPClient } from '@modelcontextprotocol/sdk';

export async function POST(request: Request) {
  const { task, context } = await request.json();
  
  const client = new MCPClient({
    servers: ['github', 'vercel', 'database']
  });
  
  // Agent generiert und führt Code aus
  const result = await client.executeTask(task, {
    enableCodeExecution: true,
    sandbox: 'secure',
    context
  });
  
  return Response.json(result);
}

React Component für MCP-gesteuerte Automation

import { useMCP } from '@/hooks/useMCP';

export function AutomatedDeployment() {
  const { execute, status } = useMCP();
  
  const handleDeploy = async () => {
    await execute(`
      1. Prüfe GitHub für neue Commits
      2. Führe Tests aus
      3. Deploye auf Hetzner Cloud
      4. Update Directus mit Deployment-Info
    `);
  };
  
  return (
    <button onClick={handleDeploy} disabled={status === 'running'}>
      {status === 'running' ? 'Deployment läuft...' : 'Deploy'}
    </button>
  );
}

Das Ökosystem: Wachsende Tool-Vielfalt

Anthropic teilt vorgefertigte MCP-Server für beliebte Enterprise-Systeme wie Google Drive, Slack, GitHub, Git, Postgres und Puppeteer.³ Die Community hat dieses Angebot massiv erweitert.

Kategorien verfügbarer MCP-Server

1. Entwicklungs-Tools: GitHub, GitLab, VS Code, Cursor
2. Cloud-Infrastruktur: AWS, Hetzner, Vercel, Cloudflare
3. Datenbanken: PostgreSQL, MongoDB, Supabase
4. CMS & Content: Directus, Ghost, Contentful
5. Kommunikation: Slack, Discord, Email
6. Browser-Automation: Playwright, Puppeteer, Selenium

Performance-Vergleich: Zahlen sprechen

Die Effizienzgewinne sind beeindruckend:

Metrik	Traditionell	Mit Code-Ausführung	Verbesserung
Token-Verbrauch	~150.000	~2.000	98,7% weniger
Latenz	Hoch (multiple Roundtrips)	Niedrig (single execution)	85-90% schneller
Kosten	€45-60/Monat	€2-5/Monat	90-95% günstiger
Fehlerrate	Mittel (jede Kette = Risiko)	Niedrig (atomare Operationen)	70% weniger Fehler

Basierend auf durchschnittlichen Nutzungsszenarien mit 50+ Tools

Ausblick: Wohin geht die Reise?

Die bedeutendste ungelöste Spannung für das nächste Jahrzehnt der KI wird dieser Trade-off sein: Während autonome Agenten durch Code, State und Skills leistungsfähiger werden, wird ihr operativer Fußabdruck und ihre Angriffsfläche exponentiell wachsen und die Zukunft der KI zu einer Platform-Engineering-Herausforderung machen, die wir alle sorgfältig navigieren müssen.⁵

Kommende Entwicklungen

1. Verbesserte Sicherheits-Frameworks: Formale Verifikation von Agent-generiertem Code
2. Spezialisierte Runtimes: Optimierte Ausführungsumgebungen für verschiedene Workload-Typen
3. Federation: Verteilte MCP-Server-Netzwerke für Enterprise-Szenarien
4. AI-native IDEs: Entwicklungsumgebungen, die Code-Ausführung als First-Class-Citizen behandeln

Fazit: Ein neues Paradigma

Code-Ausführung mit MCP markiert einen Wendepunkt in der Entwicklung von KI-Agenten. Das Pattern geht die Token-Kosten beim Laden von Tool-Definitionen und beim Routing großer Zwischenergebnisse durch den Kontext direkt an, indem es MCP-Server als Code-APIs präsentiert und die Arbeit in eine Sandbox-TypeScript-Runtime verlagert.²

Die Vorteile sind überwältigend:

• 98,7% weniger Token-Verbrauch
• Drastisch reduzierte Latenz
• Verbesserte Fehlerbehandlung
• Wiederverwendbare Skills
• Skalierbare Architektur

Für Web-Entwickler bedeutet das: Die Tools, die wir täglich nutzen – von GitHub über Hetzner bis zu Directus – können nun nahtlos orchestriert werden. Ein Agent kann eigenständig:

• Code committen und deployen
• Datenbanken migrieren
• CMS-Inhalte aktualisieren
• API-Tests durchführen
• Monitoring-Dashboards updaten

All das nicht durch mühsame manuelle Integration, sondern durch standardisierte, code-basierte Interaktionen.

Die Ära der isolierten KI-Modelle ist vorbei. Willkommen in der Welt der vernetzten, code-ausführenden Agenten – einer Welt, in der KI nicht mehr nur antwortet, sondern handelt.

---

Quellen

1. Anthropic Engineering Blog: „Code execution with MCP: building more efficient AI agents“ (https://www.anthropic.com/engineering/code-execution-with-mcp)
2. MarkTechPost: „Anthropic Turns MCP Agents Into Code First Systems“ (November 2025)
3. Anthropic: „Introducing the Model Context Protocol“ (https://www.anthropic.com/news/model-context-protocol)
4. Simon Willison: „Code execution with MCP: Building more efficient agents“ (November 2025)
5. i10x.ai: „Anthropic’s Code Execution with MCP: i10x Analysis“ (November 2025)
6. ExecuteAutomation: Playwright MCP Server (https://github.com/executeautomation/mcp-playwright)
7. Anthropic Documentation: Model Context Protocol (https://docs.anthropic.com/en/docs/agents-and-tools/mcp)

---

Über den Autor: Dieser Artikel entstand im Kontext moderner Web-Entwicklung mit React, Next.js und FastAPI, mit besonderem Fokus auf die Integration von KI-gesteuerten Workflows in österreichische Web-Development-Studios.