# Vergleich — Claude Code vs. Alternativen

## Feature-Matrix

| Aspekt | Claude Code | Codex | OpenCode | Hermes |
|--------|-------------|-------|----------|--------|
| **Hook-System** | Native (settings.json) | Keine | Keine (Plugin SDK geplant) | Keine |
| **MCP Support** | Ja (vollständig) | Nein | Ja (SDK) | Nein |
| **additionalContext** | Ja (5 Hook-Events) | Nein | Nein | Nein |
| **Tool Blocking** | PreToolUse deny | Sandbox only | Permissions | Tool Restrictions |
| **System Prompt** | --append-system-prompt | Hardcoded | Unbekannt | Bounded |
| **Startup Time** | ~100ms (native binary) | ~200ms (Node) | ~300ms | Variabel |
| **Binary Size** | ~300MB | ~50MB | ~148MB | Variabel |
| **Output Format** | JSONL + Text | JSONL | Likely JSONL | Variabel |
| **Memory** | Unbegrenzt wachsend | Unbekannt | Unbekannt | Hard Cap ~800 Tokens |
| **Skills** | On-Demand möglich (via Sidecar) | Skills System | Plugin SDK | On-Demand (native) |
| **Context Cap** | Kein Limit (CLI-kontrolliert) | Unbekannt | Unbekannt | 20.000 Zeichen |
| **Enforcement** | Soft-Constraints (CLAUDE.md) | Sandbox | Permissions | Sandboxing + Approval Gates |
| **Compression** | Automatisch (nicht steuerbar) | Unbekannt | Unbekannt | 85% Context Trigger |
| **Agent Mode** | Push (Hooks feuern Events) | Pull (File Watching, JSONL) | Hybrid (MCP + Polling) | TBD |
| **Kosten/1M Token** | $3 (SubAgents) / $15 (Opus) | Variabel | Variabel | $0 (lokal) |

---

## Claude Code Stärken

### 1. Hook-System — Einzigartiger Vorteil

Claude Code ist das einzige der verglichenen Tools mit einem nativen, synchronen Hook-System:

- **UserPromptSubmit:** Kontext VOR der Verarbeitung injizieren
- **PreToolUse:** Aktionen BLOCKIEREN oder MODIFIZIEREN
- **PostToolUse:** Async Analyse NACH Aktionen
- **SessionStart/Stop:** Lifecycle Management

Kein anderes Tool in dieser Übersicht bietet dieses Level an Kontrolle über den Agent-Loop.

### 2. additionalContext API

- Diskreter Kontext-Kanal — nicht als Message für den Nutzer sichtbar
- 3-in-1 bei PreToolUse: Permission + Input-Modifikation + Kontext gleichzeitig
- Ermöglicht Dual-Agent-Architektur (Sidecar-NG als Sidecar zum Haupt-Agent)

### 3. MCP Integration

- Flexibler als Codex Skills (statisch) oder Hermes (kein MCP)
- Gemini als Research-Backend einsetzbar
- OpenCode als Execution-Backend einsetzbar
- Erweiterbar für beliebige externe Tools

### 4. CLI Flags

- `--append-system-prompt` funktioniert und ist dokumentiert
- `--output-format json` für strukturiertes Parsing
- `--agent` für Agent-Switching
- Comprehensive Debug Logging verfügbar

### 5. Performance

- Schnellster Startup (~100ms, native binary)
- Direkte Hook-Unterstützung ohne Adapter
- Kein Post-Processor nötig

---

## Claude Code Schwächen

### 1. Kein Attention Budget Management

- System Prompts wachsen unbegrenzt — alle Skills gleichzeitig injiziert
- Keine situative Priorisierung (relevante Skills vs. irrelevante)
- Ergebnis: Regeln können sich gegenseitig auslöschen oder abschwächen
- Hermes löst das nativ durch On-Demand Skill-Loading

### 2. Fehlende Hook-Events

- Kein `SessionEnd` Hook — Cleanup und Session-Recap nicht erzwingbar
- Kein `PermissionRequest` Hook — Approval-Flow nicht steuerbar
- `Stop` Hook: kein `additionalContext` möglich
- Hooks sind eingefroren bei Session-Start — keine dynamische Registrierung

### 3. Memory ohne Grenzen

- `MEMORY.md` wächst ohne Limit
- Keine automatische Zusammenfassung oder Expiry für veraltete Einträge
- Vergleich: Hermes Hard Cap 800 Tokens MEMORY.md, 500 Tokens USER.md, automatische Kompression bei 85% Auslastung

### 4. Enforcement nur soft

- `CLAUDE.md` = Text-Appelle, keine technischen Gates
- Einziges echtes Enforcement: `PreToolUse deny` — muss extern gebaut werden (Sidecar)
- Kein natives Rule-Enforcement wie Hermes (Sandboxing + Approval Gates + Tool Restrictions)

### 5. Keine Cross-Session Awareness

- Jede Session startet ohne Wissen über vorherige Sessions
- Kein Drift-Detection Mechanismus eingebaut
- Session-Recaps nicht enforced — abhängig von externem Tooling

---

## Hermes als Referenz-Architektur

Hermes Agent (NousResearch) löst dasselbe Problem — ein LLM das sich nicht an Regeln hält — ohne zweiten Agenten. Stattdessen: harte strukturelle Grenzen.

| Feature | Hermes | Claude Code |
|---------|--------|-------------|
| Memory | Hard Cap ~800 Tokens MEMORY.md, ~500 Tokens USER.md | Unbegrenzt (12 KB+ MEMORY.md) |
| Skills | On-Demand: Agent lädt nur wenn nötig | Alle 40+ Skills immer injiziert |
| Context Cap | 20.000 Zeichen hard limit | Kein Limit |
| Enforcement | Sandboxing + Approval Gates + Tool Restrictions | Soft-Constraints (Text) |
| Compression | Automatisch bei 85% Context | Nicht steuerbar |

**Philosophie-Unterschied:** Hermes = weniger Intelligenz, mehr Struktur. Bounded memory statt unbegrenztem Wachstum. Approval prompts statt LLM-Judge. Tool restrictions statt Compliance-Monitoring.

**Implikation für Sidecar-NG:** Die Stärken von Hermes (Bounded Memory, On-Demand Skills) sind Ziele für Sidecar V8 — aber als Sidecar-Layer über Claude Code, nicht als Ersatz.

---

## OpenCode Integration — Status

**Getestet und dokumentiert:**

| Endpoint | Port | Ergebnis |
|----------|------|---------|
| /events | 3000 | Nur WebUI HTML — nutzlos für Sidecar |
| /global/event | 4096 | Nur Meta-Events (heartbeat, session.created) |
| REST API | — | 404 oder leere Listen |
| Message-Content | — | Im TUI-Bus gefangen, nicht extern zugänglich |

**Fazit:** Adapter-Code korrekt implementiert, aber OpenCode liefert die relevanten Daten nicht über externe APIs. Status: `enabled: false`. Wartet auf OpenCode API-Verbesserungen oder Plugin SDK Fertigstellung.

---

## Codex Integration — Status

**Architektur-Unterschied zu Claude Code:**

- Claude Code: Push-Mode — Agent feuert Events aktiv via Hooks
- Codex: Pull-Mode — File Watching, JSONL Events polling-basiert
- Kein direktes Hook-System — Adapter muss JSONL parsen

**Sidecar V8 Adapter-Roadmap:**

| Phase | Adapter | Methode |
|-------|---------|---------|
| Phase 1 | ClaudeCodeAdapter | Refactor bestehender Code |
| Phase 3 | CodexAdapter | JSONL-basiert (Pull) |
| Phase 4 | OpenCodeAdapter | MCP-Hybrid |
| Phase 5 | HermesAdapter | TBD |

**Entscheidung E2:** Reihenfolge Claude Code → Codex → OpenCode → Hermes. Kein Cursor.

---

## Kosten-Vergleich (Delegation)

| Methode | Kosten/1M Token | Quelle |
|---------|----------------|--------|
| Claude Opus (direkt) | ~$15 | Standard |
| Claude SubAgents (Sonnet) | ~$3 | Standard |
| /chef via OpenCode MCP | ~$3 | ORCHESTRATION_GUIDE |
| /crew via CrewAI (Gemini+MiniMax) | ~$0.60 | ORCHESTRATION_GUIDE |
| /langgraph Manager | ~$0.70 | ORCHESTRATION_GUIDE |
| Gemini MCP Research | ~$0.10 | ANALYSE_KOMPLETT |
| Haiku Background | ~$0.25 | CLAUDE.md |

**Einsparung durch Delegation:** /crew statt SubAgents = ~85% Kostenreduktion bei geeigneten Tasks.

**Empfehlung:** SubAgents (Sonnet) für Code-Qualität und Hook-Integration. /crew oder /langgraph für Recherche, Analyse, und parallele Batch-Tasks.

---

## Zusammenfassung

Claude Code ist das stärkste Tool für agentic Coding-Workflows mit externem Sidecar-System, primär wegen des Hook-Systems und der `additionalContext` API. Die Schwächen — unbegrenztes Memory-Wachstum, fehlende strukturelle Enforcement-Mechanismen, keine Cross-Session Awareness — sind bekannt und werden durch Sidecar-NG als externen Layer adressiert, nicht durch Tool-Wechsel.

Hermes bleibt als Referenz-Architektur relevant. Die Bounded-Memory- und On-Demand-Skills-Konzepte sind Ziele für Sidecar V8.

OpenCode und Codex sind als Sidecar-Targets (Adapter) geplant, nicht als Ersatz für Claude Code in der primären Workflow-Rolle.