Das Ausgangsproblem

Im November 2025 veröffentlichte Anthropic einen Artikel über Code Execution mit MCP¹. Das Ergebnis in einem konkreten Beispiel:

“Ein Workflow, der vorher 150.000 Tokens verbrauchte, nutzt jetzt nur noch 2.000 Tokens.”

Das sind 98,7% weniger Kosten – in diesem spezifischen Fall.

Wie funktioniert das? Durch Code Execution with MCP.

Dieser Artikel erklärt, was dahinter steckt – und wie du es nutzt.

Das Token-Problem: Eine teure Unsitte

Bevor wir zur Lösung kommen, lass uns das Problem verstehen.

Wie KI-Tools heute arbeiten (klassisches Tool-Calling)

Wenn Claude, ChatGPT oder Cursor mit externen Tools arbeiten, funktioniert das so:

Schritt 1: Alle Tools in den Kontext laden

// Beim Start werden ALLE verfügbaren Tools definiert
const tools = [
  {
    name: "read_file",
    description: "Liest eine Datei vom Dateisystem",
    parameters: { /* 200 Zeilen Schema */ }
  },
  {
    name: "write_file",
    description: "Schreibt eine Datei",
    parameters: { /* 150 Zeilen Schema */ }
  },
  {
    name: "list_files",
    description: "Listet Dateien auf",
    parameters: { /* 100 Zeilen Schema */ }
  },
  // ... 47 weitere Tools
]

// Jede Anfrage schickt diese Definitionen mit
// → ~10.000 Tokens nur für Tool-Beschreibungen

Schritt 2: Tool aufrufen, Daten durchs Modell schicken

Du: "Zeig mir alle Security-Issues auf GitHub"

KI → Tool-Call: list_github_issues()
Tool → KI: [Sendet 500 Issues zurück]

KI verarbeitet alle 500 Issues (= 50.000 Tokens)
KI filtert: "Nur Security-Issues"
KI antwortet: "Es gibt 3 Security-Issues..."

Verbraucht: 60.000 Tokens
Davon nützlich: 300 Tokens (die 3 Issues)
Verschwendung: 59.700 Tokens (99,5%)

Schritt 3: Bei jedem weiteren Tool-Call wiederholt sich das

Du: "Erstelle für jedes Issue ein Sentry-Ticket"

KI → 3x Tool-Call: create_sentry_ticket()
Jeder Call geht durchs Modell
Jeder Call kostet weitere Tokens

Total: 150.000 Tokens

Warum ist das so teuer?

Problem 1: Tool-Definitionen 50 Tools × 200 Zeilen = 10.000 Tokens bei jeder Anfrage

Problem 2: Daten-Overhead Alle Daten gehen durchs Modell, auch wenn 99% irrelevant sind

Problem 3: Wiederholte Roundtrips Jeder Tool-Call = neuer Context → neue Kosten

Problem 4: Keine Optimierung Das Modell kann nicht “lokal filtern” – es muss alles verarbeiten

Die Kosten in Zahlen

Bei Claude 3.5 Sonnet (Stand 2025)²:

• Input: 3 € pro 1 Million Tokens
• Output: 15 € pro 1 Million Tokens

Beispiel-Szenario: 10 Entwickler

Jeder macht 200 Anfragen/Tag mit durchschnittlich 15.000 Tokens:

• 10 × 200 = 2.000 Anfragen/Tag
• 2.000 × 15.000 = 30 Millionen Tokens/Tag
• 30 Mio. × 20 Arbeitstage = 600 Millionen Tokens/Monat

Kosten:

• Input (400 Mio.): 400 × 0,003 € = 1.200 €
• Output (200 Mio.): 200 × 0,015 € = 3.000 €
• Total: 4.200 €/Monat

Und das ist nur für Tool-Definitionen + Overhead. Die eigentliche Arbeit kommt noch dazu.

Die Lösung: Code Execution with MCP

Die Grundidee: KI als Programmierer statt als Befehlsempfänger

Anthropic hat einen fundamentalen Wechsel vorgeschlagen, der auf den ersten Blick simpel klingt, aber alles verändert:

Statt dass die KI Tools aufruft und auf Ergebnisse wartet, schreibt sie ein Programm, das die Arbeit macht.

Warum ist das revolutionär?

Stell dir vor, du bittest einen Assistenten, 1.000 E-Mails durchzugehen und nur die wichtigen herauszufiltern.

Variante A (Tool-Calling = bisheriger Ansatz):

Du: "Zeig mir die erste E-Mail"
Assistent: [Liest E-Mail 1 vor - 2 Minuten]
Du: "Ist die wichtig?"
Assistent: "Nein"
Du: "Zeig mir die zweite E-Mail"
Assistent: [Liest E-Mail 2 vor - 2 Minuten]
Du: "Ist die wichtig?"
Assistent: "Nein"
...
[1.000 E-Mails × 2 Minuten = 33 Stunden]

Das ist Tool-Calling: Jeder einzelne Schritt geht durch dich (das Modell) hindurch.

Variante B (Code Execution = neuer Ansatz):

Du: "Schreib mir ein Skript, das alle E-Mails durchgeht und nur die wichtigen herausfiltert"
Assistent: [Schreibt Skript in 2 Minuten]
Assistent: [Führt Skript aus - 30 Sekunden]
Assistent: "Fertig. Hier sind die 12 wichtigen E-Mails"

Total: 2,5 Minuten statt 33 Stunden

Das ist Code Execution: Du gibst die Anweisung, die KI schreibt ein Programm, das Programm macht die Arbeit.

Wie funktioniert das konkret?

Klassisches Tool-Calling (bisheriger Weg):

1. Du fragst: “Welche GitHub Issues sind offen?”
2. Claude ruft Tool auf: list_github_issues()
3. GitHub sendet 500 Issues an Claude
4. Claude verarbeitet alle 500 Issues (= 50.000 Tokens verbrannt)
5. Claude filtert im Kopf: “Nur Security-Issues”
6. Claude antwortet: “3 Security-Issues gefunden”

Jeder Datensatz ging durchs Modell → teuer, langsam

Code Execution (neuer Weg):

1. Du fragst: “Welche GitHub Issues sind offen?”
2. Claude schreibt ein Skript:

import { github } from '@mcp/github'

// Hole Issues
const issues = await github.listIssues({ repo: 'myorg/myrepo' })

// Filtere LOKAL (nicht durchs Modell!)
const security = issues.filter(i => i.labels.includes('security'))

// Gib nur kompaktes Ergebnis zurück
return {
  total: issues.length,
  securityIssues: security.length,
  topIssues: security.slice(0, 3)
}

3. Das Skript läuft auf deinem Rechner (nicht durchs Modell)
4. 500 Issues werden lokal verarbeitet (kein Token-Verbrauch)
5. Nur das kompakte Ergebnis geht zurück: “500 total, 3 Security-Issues”
6. Claude formatiert die Antwort

Die Daten gingen NICHT durchs Modell → günstig, schnell

Warum spart das so viel?

Token-Verbrauch im Vergleich:

Tool-Calling:
├─ Tool-Definitionen laden: 10.000 Tokens
├─ 500 Issues durchs Modell: 50.000 Tokens
├─ Verarbeitung im Modell: 10.000 Tokens
└─ Antwort generieren: 5.000 Tokens
   Total: 75.000 Tokens

Code Execution:
├─ Skript schreiben: 1.000 Tokens
├─ Daten lokal verarbeiten: 0 Tokens (läuft außerhalb)
├─ Kompaktes Ergebnis zurück: 500 Tokens
└─ Antwort generieren: 1.000 Tokens
   Total: 2.500 Tokens

Ersparnis: 72.500 Tokens = 97%

Das zentrale Prinzip: “Don’t send data through the model”

Alte Welt: Daten → Modell → Verarbeitung → Ergebnis
Neue Welt: Daten → Skript (lokal) → Ergebnis → Modell

Die KI wird vom Arbeiter (der alles selbst macht) zum Koordinator (der Programme schreibt, die die Arbeit machen).

Warum hat das vorher niemand gemacht?

Gute Frage! Die Antwort: Es war zu riskant.

Frühere KI-Modelle (GPT-3, GPT-4, Claude 1/2) haben beim Code-Schreiben zu viele Fehler gemacht:

• Infinite Loops
• Falsche API-Calls
• Security-Probleme

Mit Claude 3.5 Sonnet und neueren Modellen (Oktober 2024+) ist die Code-Qualität so gut, dass Code Execution sicher ist:

• Sandboxed Execution (Code läuft isoliert)
• Timeout-Protection (max. 30 Sekunden)
• Resource Limits (max. 512 MB RAM)

Anthropic hat im November 2025 Code Execution offiziell für Production freigegeben¹.

Das neue Paradigma

Alt (Tool-Calling):

Modell sagt: "Rufe list_github_issues auf"
→ Tool gibt alle Issues zurück
→ Modell verarbeitet alle
→ Modell filtert

Neu (Code Execution):

Modell schreibt Code:
  const issues = await github.listIssues()
  const security = issues.filter(i => i.label === 'security')
  return security

→ Code wird LOKAL ausgeführt
→ Nur Resultat geht zurück ans Modell

Der entscheidende Unterschied

Bei Tool-Calling: Das Modell ist der Flaschenhals – alles geht durch es hindurch.

Bei Code Execution: Das Modell ist der Dirigent – es schreibt Code, der autonom läuft.

Metapher: Statt dass du jeden einzelnen Baustein eines IKEA-Regals selbst zusammenschraubst, schreibt die KI dir eine Bauanleitung, und ein Roboter baut das Regal nach Anleitung. Du checkst nur am Ende: “Passt das?”

Ein konkretes Beispiel

Aufgabe: “Analysiere alle GitHub Issues und gruppiere nach Label”

Mit Tool-Calling:

// Schritt 1: Model ruft Tool auf
Model: call_tool("list_github_issues")

// Schritt 2: Tool gibt ALLES zurück
Tool: [
  { id: 1, title: "Bug in Login", labels: ["bug", "frontend"] },
  { id: 2, title: "Security issue", labels: ["security"] },
  // ... 498 weitere Issues
]
// → 50.000 Tokens durchs Modell

// Schritt 3: Model gruppiert (im Kopf)
Model: "Lass mich die Labels zählen..."
// → Weitere 20.000 Tokens für Verarbeitung

// Schritt 4: Antwort
Model: "Es gibt 127 Bug-Issues, 43 Security-Issues, ..."
// → 5.000 Tokens Output

Total: 75.000 Tokens

Mit Code Execution:

// Schritt 1: Model schreibt Code (einmal, zu Beginn)
Model: "Ich schreibe ein Skript, das die Issues gruppiert"

const code = `
import { github } from '@mcp/github'

const issues = await github.listIssues({ repo: 'myorg/myrepo' })

const labelGroups = {}
for (const issue of issues) {
  for (const label of issue.labels) {
    labelGroups[label] = (labelGroups[label] || 0) + 1
  }
}

return labelGroups
`

// Schritt 2: Code läuft LOKAL (nicht durchs Modell)
// 500 Issues werden lokal verarbeitet
// Kein Token-Verbrauch für die Verarbeitung

// Schritt 3: Nur kompaktes Resultat zurück
Result: {
  bug: 127,
  security: 43,
  frontend: 89,
  backend: 52,
  ...
}
// → 500 Tokens zurück ans Modell

// Schritt 4: Model formatiert Antwort
Model: "Es gibt 127 Bug-Issues, 43 Security-Issues, ..."
// → 1.000 Tokens Output

Total: 2.500 Tokens (97% Ersparnis!)

Warum funktioniert das?

1. Progressive Tool Discovery

Statt alle 50 Tools vorab zu laden:

// Tool-Calling: Alles im Kontext
tools = [tool1, tool2, ..., tool50]  // 10.000 Tokens

// Code Execution: On-Demand Import
import { github } from '@mcp/github'  // 100 Tokens

2. In-Environment Processing

Datenverarbeitung läuft außerhalb des Modells:

// 10.000 Log-Einträge filtern
const errors = logs.filter(l => l.level === 'error')

// Nur Summary zurück ans Modell
return {
  errorCount: errors.length,
  topErrors: errors.slice(0, 5)
}

3. Besserer Control Flow

Loops und Conditionals im Code, nicht durch Tool-Chains:

// Statt 20 Tool-Calls
for (const file of files) {
  if (file.endsWith('.ts')) {
    await linter.check(file)
  }
}

4. State Persistence

Zwischenschritte speichern, ohne durchs Modell zu gehen:

// Checkpoint nach jedem Schritt
await fs.writeFile('.state.json', JSON.stringify({
  processed: 42,
  remaining: files.slice(42)
}))

Die 7 Vorteile im Detail

1. Massive Token-Effizienz

Ersparnis: 50-98% (je nach Use Case)

Warum: Nur Code-Generation und Resultate verbrauchen Tokens, nicht die Datenverarbeitung.

Beispiel:

// Tool-Calling: 100.000 Tokens
// - 10.000 für Tool-Definitionen
// - 80.000 für 1.000 Datensätze durchs Modell
// - 10.000 für Verarbeitung

// Code Execution: 3.000 Tokens
// - 1.000 für Code-Generation
// - 1.000 für kompaktes Resultat
// - 1.000 für Antwort

2. Schnellere Ausführung

Warum: Keine Roundtrips für jeden Tool-Call.

Vorher:

Request → Model (2s) → Tool (1s) → Model (2s) → Tool (1s) → ...
Total: 10+ Sekunden

Nachher:

Request → Model schreibt Code (2s) → Code läuft lokal (0,5s) → Done
Total: 2,5 Sekunden

3. Wiederverwendbare Skills

Code kann als “Skills” gespeichert und wiederverwendet werden:

// Skill: "Analysiere Repository Health"
export async function analyzeRepoHealth(repo: string) {
  const issues = await github.listIssues({ repo })
  const prs = await github.listPullRequests({ repo })
  const commits = await github.listCommits({ repo, since: '30d' })

  return {
    openIssueCount: issues.length,
    stalePRs: prs.filter(pr => daysSince(pr.updated) > 7).length,
    commitFrequency: commits.length / 30,
    health: calculateScore(issues, prs, commits)
  }
}

// Skill kann in verschiedenen Projekten genutzt werden

4. Privacy & Data Residency

Sensible Daten müssen nicht durchs Modell:

// Passwort-Hashing lokal
const hash = await bcrypt.hash(password, 10)
await db.users.update({ id, passwordHash: hash })

// Nur Status zurück (kein Passwort durchs Modell)
return { success: true }

Use Case: DSGVO-Compliance, vertrauliche Kundendaten, Firmen-Interna.

5. Bessere Fehlerbehandlung

Code kann komplexe Error-Handling machen:

try {
  const data = await api.fetchData()
  return processData(data)
} catch (error) {
  if (error.code === 'RATE_LIMIT') {
    await sleep(error.retryAfter * 1000)
    return api.fetchData() // Retry
  }
  throw error
}

Bei Tool-Calling müsste jeder Retry durchs Modell.

6. Komplexe Workflows

Multi-Step-Prozesse ohne Token-Overhead:

// Workflow: Cleanup alte Daten
const deleted = {
  sessions: 0,
  cacheEntries: 0,
  logs: 0
}

// Schritt 1: Sessions
const oldSessions = await db.sessions
  .where('expiresAt', '<', Date.now())
  .delete()
deleted.sessions = oldSessions.count

// Schritt 2: Cache
const staleCache = await redis.keys('cache:*')
  .filter(key => isExpired(key))
for (const key of staleCache) {
  await redis.del(key)
  deleted.cacheEntries++
}

// Schritt 3: Logs
const oldLogs = await db.logs
  .where('createdAt', '<', Date.now() - 90 * DAY)
  .delete()
deleted.logs = oldLogs.count

// Nur Summary zurück
return deleted

Mit Tool-Calling: 3 × Roundtrips, jeder Schritt durchs Modell → 50.000 Tokens Mit Code Execution: Ein Skript, läuft durch → 2.000 Tokens

7. Testbarkeit

Code kann getestet werden, bevor er läuft:

// Unit Test für KI-generierten Code
describe('analyzeRepoHealth', () => {
  it('should calculate health score correctly', async () => {
    const result = await analyzeRepoHealth('test-repo')
    expect(result.health).toBeGreaterThan(0)
    expect(result.health).toBeLessThanOrEqual(100)
  })
})

Bei Tool-Calling: Keine Tests möglich, nur Trial-and-Error.

Wie aktiviere ich Code Execution?

Code Execution ist in Claude 3.5 Sonnet (und neueren Modellen) verfügbar. Du musst es aktivieren.

In Claude Desktop

Schritt 1: Öffne Claude Settings

Claude Desktop → Settings → Advanced

Schritt 2: Aktiviere “Code Execution”

☑ Enable Code Execution with MCP
☑ Allow file system access (optional)

Schritt 3: Teste es

Du: "Schreibe ein Skript, das die Primzahlen bis 100 berechnet"

Claude: "Ich werde ein Skript schreiben und ausführen..."

[Claude generiert Code]
[Code läuft lokal]
[Ergebnis: 2, 3, 5, 7, 11, ...]

Claude: "Es gibt 25 Primzahlen zwischen 1 und 100."

In Claude API

Wenn du die Claude API nutzt (z.B. für eigene Apps):

import Anthropic from '@anthropic-ai/sdk'

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY
})

const response = await client.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 4096,

  // Code Execution aktivieren
  tools: [{
    type: 'code_execution',
    language: 'typescript', // oder 'python'

    // Optional: MCP Server für Code
    mcp_servers: [{
      name: 'github',
      transport: 'http',
      url: 'https://mcp.github.com'
    }]
  }],

  messages: [{
    role: 'user',
    content: 'Analysiere die offenen GitHub Issues in myorg/myrepo'
  }]
})

// Claude schreibt Code, führt ihn aus, gibt Resultat zurück
console.log(response.content)

In Cursor IDE

Cursor unterstützt Code Execution nativ:

Schritt 1: Öffne Cursor Settings (Cmd+,)

{
  "cursor.ai": {
    "model": "claude-3-5-sonnet",
    "features": {
      "codeExecution": true
    }
  }
}

Schritt 2: Nutze Composer (Cmd+I)

Du: "Analysiere alle TypeScript-Dateien und zeige Komplexität"

Cursor: [Schreibt Code]
        [Führt aus]
        [Zeigt Ergebnis]

In Zed mit Claude

Zed bietet Claude-Modelle über seinen gehosteten Service an. Verfügbare Modelle (Stand 2025):

• Default (wahrscheinlich Sonnet 4)
• Opus (Opus 4.1)
• Haiku (Haiku 4.5)
• Sonnet 4.5 (falls verfügbar)

Wichtig: Alle Claude-4-Modelle unterstützen Code Execution. Die Zed-Dokumentation spezifiziert nicht, ob Code Execution standardmäßig aktiv ist oder manuell aktiviert werden muss.

Modell-Auswahl in Zed:

1. Öffne den Assistant (Cmd+Shift+A)
2. Wähle oben im Panel das gewünschte Modell

Empfehlung für Code Execution:

• Default/Sonnet ist der beste Kompromiss (Performance + Kosten)
• Haiku ist am schnellsten und günstigsten, aber weniger leistungsfähig
• Opus ist am leistungsfähigsten, aber teuerste Option

Teste, ob Code Execution funktioniert:

Du (im Zed Assistant): "Schreib ein Skript, das alle .ts-Dateien 
in diesem Projekt zählt und nach Größe sortiert ausgibt"

Wenn Claude Code Execution nutzt, siehst du:
→ Claude schreibt Code
→ Code wird ausgeführt
→ Ergebnis wird angezeigt

Wenn nicht, schreibt Claude nur Code-Vorschläge ohne Ausführung.

Hinweis: Zed nutzt entweder seinen gehosteten Service oder deine eigene Anthropic API-Key-Konfiguration. Die verfügbaren Features können sich unterscheiden.

Die Kostenrechnung: Wie viel sparst du wirklich?

Schauen wir uns verschiedene Szenarien an.

Szenario 1: Einzelperson (Freelancer)

Nutzung: 50 Anfragen/Tag mit KI-Tools

Ohne Code Execution:

• 50 × 15.000 Tokens = 750.000 Tokens/Tag
• 750k × 20 Tage = 15 Mio. Tokens/Monat
• Input (10 Mio.): 10 × 0,003 € = 30 €
• Output (5 Mio.): 5 × 0,015 € = 75 €
• Total: 105 €/Monat

Mit Code Execution (70% Ersparnis):

• 50 × 4.500 Tokens = 225.000 Tokens/Tag
• 225k × 20 = 4,5 Mio. Tokens/Monat
• Input (3 Mio.): 9 €
• Output (1,5 Mio.): 22,50 €
• Total: 31,50 €/Monat

Ersparnis: 73,50 €/Monat = 882 €/Jahr

Szenario 2: Kleines Team (5 Entwickler)

Nutzung: 100 Anfragen/Tag pro Person

Ohne Code Execution:

• 5 × 100 × 15.000 = 7,5 Mio. Tokens/Tag
• 7,5 Mio. × 20 = 150 Mio. Tokens/Monat
• Input (100 Mio.): 300 €
• Output (50 Mio.): 750 €
• Total: 1.050 €/Monat

Mit Code Execution (70% Ersparnis):

• 150 Mio. × 0,3 = 45 Mio. Tokens/Monat
• Input (30 Mio.): 90 €
• Output (15 Mio.): 225 €
• Total: 315 €/Monat

Ersparnis: 735 €/Monat = 8.820 €/Jahr

Szenario 3: Größeres Team (20 Entwickler)

Nutzung: 150 Anfragen/Tag pro Person

Ohne Code Execution:

• 20 × 150 × 15.000 = 45 Mio. Tokens/Tag
• 45 Mio. × 20 = 900 Mio. Tokens/Monat
• Input (600 Mio.): 1.800 €
• Output (300 Mio.): 4.500 €
• Total: 6.300 €/Monat

Mit Code Execution (80% Ersparnis bei Scale):

• 900 Mio. × 0,2 = 180 Mio. Tokens/Monat
• Input (120 Mio.): 360 €
• Output (60 Mio.): 900 €
• Total: 1.260 €/Monat

Ersparnis: 5.040 €/Monat = 60.480 €/Jahr

Szenario 4: Enterprise (100+ Entwickler)

Ohne Code Execution: ~30.000 €/Monat Mit Code Execution: ~6.000 €/Monat Ersparnis: 24.000 €/Monat = 288.000 €/Jahr

Wann nutzen, wann nicht?

** Code Execution ist ideal für:

Datenintensive Aufgaben

• “Analysiere alle 10.000 Log-Einträge”
• “Filtere 500 GitHub Issues nach Kriterien”
• “Vergleiche Preise von 200 Produkten”

Wiederholte Operationen

• “Prüfe alle TypeScript-Files auf Fehler”
• “Aktualisiere Metadaten für 100 Bilder”
• “Cleanup alte Daten in 5 Tabellen”

Komplexe Workflows

• Multi-Step-Prozesse mit Abhängigkeiten
• Bedingte Logik (if/else, loops)
• Error-Handling und Retries

Privacy-kritische Daten

• Kundendaten, die nicht durchs Modell sollen
• Firmeninterna
• DSGVO-relevante Informationen

High-Volume Nutzung

• Teams mit 5+ Entwicklern
• Production-Systeme
• Automatisierte Workflows

** Übertrieben für:

Einfache Fragen

• “Was macht diese Funktion?”
• “Erkläre mir das Konzept”
• “Formatiere diesen Code”

Einzelne Tool-Calls

• “Lies eine Datei”
• “Erstelle ein GitHub Issue”
• “Sende eine E-Mail”

Ad-hoc Experimente

• Prototyping
• Quick & Dirty Skripte
• Einmalige Abfragen

Sehr kleine Datenmengen

• < 10 Datensätze
• Einzelne Objekte
• Kleine Dateien

Best Practices für Code Execution

1. Klare Aufgabenstellung

** Schlecht: "Mach was mit den GitHub Issues"

** Gut: "Analysiere alle offenen GitHub Issues in myorg/myrepo,
        gruppiere nach Labels und zeige die 5 häufigsten Labels"

2. Definiere Output-Format

** Schlecht: "Analysiere die Daten"

** Gut: "Analysiere die Daten und gib zurück:
        {
          total: number,
          byCategory: Record<string, number>,
          topItems: Array<{name: string, count: number}>
        }"

3. Nutze Type-Safe Code

// TypeScript statt JavaScript
import { z } from 'zod'

const ResultSchema = z.object({
  total: z.number(),
  items: z.array(z.object({
    name: z.string(),
    count: z.number()
  }))
})

const result = ResultSchema.parse(data)

4. Error-Handling einbauen

try {
  const data = await fetchData()
  return processData(data)
} catch (error) {
  return {
    success: false,
    error: error.message,
    fallback: getDefaultData()
  }
}

5. Logging für Debugging

console.log(`Processing ${items.length} items...`)
console.log(`Filtered to ${filtered.length} relevant items`)
console.log(`Grouped into ${Object.keys(groups).length} categories`)
return groups

Zusammenfassung: Die 5 wichtigsten Erkenntnisse

1. Paradigmenwechsel Code Execution dreht Tool-Calling um: Statt Daten durchs Modell zu schicken, schreibt das Modell Code, der lokal läuft.

2. Massive Kosteneinsparung 50-98% weniger Tokens (je nach Use Case). Bei Teams mit 20 Entwicklern: ~60.000 €/Jahr gespart.

3. Schneller und skalierbarer Keine Roundtrips für jeden Tool-Call. Komplexe Workflows laufen in Sekunden statt Minuten.

4. Privacy by Design Sensible Daten müssen nicht durchs Modell. Ideal für DSGVO-Compliance und vertrauliche Informationen.

5. Best Practice für Production Ab 5+ Entwicklern oder datenintensiven Aufgaben ist Code Execution der neue Standard.

Nächste Schritte

Jetzt aktivieren:

1. Claude Desktop → Settings → Advanced → ☑ Code Execution
2. Teste: “Analysiere alle TypeScript-Files in diesem Projekt und zeige Komplexität”
3. Beobachte die Token-Ersparnis

Viel Erfolg!

---

Quellen

Footnotes

1. Anthropic: Code execution with MCP ↩ ↩²

2. Anthropic Pricing (Stand 2025) ↩