Deep Dive: Falcon, Classifier-Sites & Experimente

Falcon — Der Geist im System

Was wir gefunden haben

In den Feature-Flags:

velvet_hammer_falcon = false
velvet_mallet_falcon = false

Falcon folgt exakt dem Muster velvet_hammer_<modell> / velvet_mallet_<modell>, wo jeder andere Eintrag ein bekanntes Claude-Modell ist (opus, sonnet, haiku, fable, mythos). Es gibt keinen Zweifel: Falcon ist ein Modell-Codename.

Falcon ist nirgends aktiv:

Nicht in lucky_cerf (Modellliste)
Nicht in velvet_hammer (Premium-Gate)
Nicht in velvet_mallet (Basis-Gate)
Nicht in cedar_lagoon (Spezial-Gate für Fable/Mythos)
Nicht in amber_tally (Pricing)

Im Binary (/opt/claude-code/bin/claude):

Falcon taucht an zwei Stellen auf:

Im Wort-Pool für zufällige Namen — “falcon” ist eines von ~200 Tiernamen die zur Generierung von zufälligen Slugs verwendet werden (wie eager-falcon oder iterative-falcon). Das erklärt Zufallstreffer wie tengu_iterative_falcon.
Als tengu_iterative_falcon — ein separater Feature-Flag (Wert: None = nicht gesetzt). Im Code wird er so verwendet:

function jpn() {
    return k("tengu_iterative_falcon", true) !== false 
        && n7r();  // → checks tengu_glowing_orbit
}

jpn() gibt true zurück wenn BEIDE Flags aktiv sind. glowing_orbit ist true, iterative_falcon ist None (undefined → default true → also auch aktiv). Die Funktion ist also aktiv.

Der Kontext im Code: jpn() wird in der Nähe von Permission-Check-Logik aufgerufen. Die Funktion Wpn konstruiert einen Prompt-Text: “run this first, exactly as written, and use its output” — das klingt nach iterativer Tool-Ausführung, bei der Claude aufgefordert wird, einen Befehl zuerst auszuführen bevor es weitermacht.

Zwei verschiedene Falcons

Kontext	Was es ist	Status
`velvet_hammer_falcon` / `velvet_mallet_falcon`	Modell-Codename in den Modell-Gate-Listen	Vorbereitet, komplett deaktiviert
`tengu_iterative_falcon`	Feature-Flag für iterative Tool-Ausführung (zufällig generierter Name)	Aktiv (None → default true)

Das heißt: der Name “Falcon” in iterative_falcon ist Zufall — ein automatisch generierter Slug aus dem Wort-Pool. Aber velvet_hammer_falcon und velvet_mallet_falcon sind absichtlich benannte Modell-Gates, weil sie dem systematischen Muster folgen.

Hypothese zum Modell Falcon

Falcon ist weder in der aktuellen Modellliste noch in den Pricing-Daten. Möglichkeiten:

Ein zukünftiges Modell das noch nicht released wurde
Ein internes Testmodell das nur Anthropic-Mitarbeiter nutzen
Ein abgesagtes Modell dessen Gates noch nicht aufgeräumt wurden
Ein Codename für ein bestehendes Modell das unter anderem Namen veröffentlicht wurde

Die Tatsache dass Falcon in BEIDEN Gate-Listen (hammer UND mallet) vorkommt, aber überall false ist, spricht für “vorbereitet aber noch nicht freigeschaltet” — eher zukünftig als abgesagt.

Teil 2: Die 8 A/B-Experimente im Detail

Experiment-Architektur

Experimente werden über GrowthBook verwaltet. Jeder Experiment-Eintrag hat:

experimentId — interner Name des Experiments
variationId — welche Variante (0 = Control, 1+ = Treatment)
value — der konkrete Wert für diese Variante

Die Experimente

1. `swift_lynx` / `cai_giggly_dream` — $100 Cloud Credit Promo

Variation 0 (Control-Gruppe)

Das aufwändigste Experiment. Enthält eine komplette Marketing-Kampagne:

{
  "endpoint": "/v1/code/promo/cloud_credit",
  "webPath": "/code/claim-credit",
  "desktopPath": "/claude-code-desktop/claim-credit",
  "claimLinkIncludesOrganization": true,
  "startup": {
    "text": "Claim a $100 bonus credit for cloud sessions",
    "buttonLabel": "Claim credit"
  },
  "limitWall": {
    "noticeLine": "While you wait, start a new cloud session by claiming a $100 credit"
  }
}

Was es tut: Zeigt eine $100 Bonus-Credit-Aktion an verschiedenen Stellen:

Beim Start von Claude Code
Wenn der User sein Limit erreicht (limitWall)
In der IDE

Der Experiment-Name cai_giggly_dream folgt dem gleichen Zufalls-Generator-Muster wie die Flag-Namen. “cai” = Claude AI Prefix?

Variation 0 = Control: Dieser Account sieht die Config, aber da es die Control-Gruppe ist, wird die Promo möglicherweise nicht angezeigt (oder anders angezeigt als in der Treatment-Gruppe).

2. `ultrareview_awareness` / `ultrareview_cli_nudges` — Feature-Werbung

Variation 1 (Treatment-Gruppe)

{
  "slash_menu": true,
  "prose_pointer": true,
  "post_commit": true,
  "startup_tip": true
}

Was es tut: Bewirbt das “Ultra Review”-Feature an 4 Stellen:

Im Slash-Menü (/)
Als Texthinweis in Antworten
Nach Commits
Als Startup-Tipp

Alle 4 Nudges sind aktiv (Variation 1, alle true). Anthropic testet aggressives In-Product-Marketing für neue Features.

3. `cowork_chrome_automode_default` — Chrome Auto-Mode Default

Variation 1 → true

Was es tut: Setzt den Chrome-Browser-Automode per Default auf “an”. Dieser Account ist in der Treatment-Gruppe — Chrome-Aktionen werden automatisch ausgeführt statt einzeln bestätigt.

4. `read_dedup_killswitch` — Read-Deduplizierung

Variation 1 → true

Was es tut: Ein Killswitch der true ist = das Feature (Read-Deduplizierung) ist AKTIV. Killswitches sind Notfall-Aus-Schalter — wenn true, läuft alles normal; false würde das Feature sofort abschalten. Anthropic testet hier, ob die Deduplizierung von Read-Operationen Probleme verursacht.

5. `mcp_subagent_prompt` — MCP Subagent Prompt

Variation 0 → false (Control-Gruppe)

Was es tut: Kontrolliert ob MCP-Tool-Calls einen speziellen Subagent-Prompt bekommen. Dieser Account ist in der Control-Gruppe (kein spezieller Prompt). Die Treatment-Gruppe bekommt vermutlich einen optimierten Prompt der MCP-Aufrufe in Subagents besser handhabt.

6. `flint_harbor` — Onboarding-Guide-Generator

Variation 1 → false

Paradox: Variation 1 (Treatment-Gruppe), aber Wert false. Das bedeutet: dieser Account ist der Treatment-Gruppe zugewiesen, aber das Feature ist trotzdem deaktiviert. Mögliche Erklärungen:

Das Experiment wurde pausiert (Wert für alle auf false gesetzt)
Die Treatment-Gruppe testet explizit das Feature-Off (A/B: mit vs. ohne)
Rollback nach einem Problem

Der vollständige Onboarding-Prompt existiert trotzdem in flint_harbor_prompt — er wird nur nicht ausgeführt.

7. `amber_prism` — Unbekanntes Cost-Feature

Variation 0 → false (Control-Gruppe)

Im amber_*-System (Kosten/Credits). Kein weiterer Kontext in den Daten. “Prism” = Licht-Aufspaltung — vielleicht eine Aufschlüsselung oder Visualisierung von Token-Kosten?

8. `plank_river_frost` — Content-Klassifizierung

Variation 0 → "user_intent"

Was es tut: Steuert die Methode der Content-Klassifizierung. "user_intent" bedeutet: der Classifier klassifiziert basierend auf der Absicht des Users, nicht basierend auf dem Content selbst. Alternative Variationen könnten sein:

"content_based" — pure Content-Analyse
"hybrid" — Kombination
"off" — keine Klassifizierung

Das ist einer der wichtigsten Flags: er bestimmt WIE der Safety-Classifier entscheidet. “user_intent” ist der sophistiziertere Ansatz — statt nur Schlüsselwörter zu matchen, versucht der Classifier zu verstehen was der User will.

Experiment-Übersicht

Experiment	Gruppe	Status	Bereich
Cloud Credit Promo	Control (0)	Config vorhanden, nicht aktiv	Marketing
Ultra Review Nudges	Treatment (1)	Alle 4 Nudges aktiv	Feature-Adoption
Chrome Automode	Treatment (1)	Auto-Mode an	UX
Read Dedup Killswitch	Treatment (1)	Feature aktiv	Performance
MCP Subagent Prompt	Control (0)	Kein spezieller Prompt	Agent-Architektur
Flint Harbor	Treatment (1)	Feature trotzdem aus	Onboarding
Amber Prism	Control (0)	Aus	Cost/Credits
Content Classification	Control (0)	user_intent Modus	Safety

Pattern: Dieser Account ist in 3 von 8 Treatment-Gruppen (ultrareview, chrome automode, read dedup). Bei den restlichen 5 ist er in der Control-Gruppe. Das ist statistisch plausibel — bei 50/50-Splits würde man ~4 Treatment erwarten.

Teil 1: Die Classifier-Architektur — Safety-Checks im Code

Was der Binary-Code zeigt

Aus dem dekompilierten Binary können wir die Safety-Check-Kategorien rekonstruieren:

Fnn = {
  dangerousRemoval: {
    bypassImmune: true,      // Kann NICHT umgangen werden
    classifierRouted: true,   // Geht zum Classifier
    autoModeDeny: true,       // Auto-Mode verweigert immer
    hostPersonOnly: false,
    localProjectionOnly: false,
    servedUnplaceable: false
  },
  backgroundOperator: {
    bypassImmune: false,      // KANN umgangen werden  
    classifierRouted: true,   // Geht zum Classifier
    autoModeDeny: false,
    hostPersonOnly: false,
    localProjectionOnly: false,
    servedUnplaceable: false
  },
  suspiciousWindowsPath: {
    bypassImmune: false,
    classifierRouted: true,
    autoModeDeny: false,
    hostPersonOnly: false,
    localProjectionOnly: false,
    servedUnplaceable: false
  },
  isolatePeerMachines: {
    bypassImmune: true,       // Kann NICHT umgangen werden
    classifierRouted: false,   // Entscheidet lokal, kein Classifier
    autoModeDeny: false,
    hostPersonOnly: false,
    localProjectionOnly: false,
    servedUnplaceable: false
  },
  restrictedMode: {
    bypassImmune: true,
    classifierRouted: false,
    autoModeDeny: false,
    hostPersonOnly: false,
    localProjectionOnly: false,
    servedUnplaceable: false
  },
  outsideReadsBlocked: {
    bypassImmune: true,
    classifierRouted: false,
    autoModeDeny: false,
    hostPersonOnly: false,
    localProjectionOnly: false,
    servedUnplaceable: false
  },
  claudeSettingsFile: {
    bypassImmune: false,
    classifierRouted: false,
    autoModeDeny: false,
    hostPersonOnly: true,     // Nur auf dem Host-Rechner relevant
    localProjectionOnly: false,
    servedUnplaceable: false
  },
  internalHardDeny: {
    bypassImmune: false,
    classifierRouted: false,
    autoModeDeny: false,
    hostPersonOnly: false,
    localProjectionOnly: false,
    servedUnplaceable: true   // Unplatzierbar bei served calls
  }
}

Die 8 Safety-Check-Kategorien

Kategorie	Bypass-immun	Classifier	Auto-Deny	Beschreibung
dangerousRemoval	✓	✓	✓	Gefährliche Löschoperationen (`rm -rf /`, etc.) — härteste Kategorie
backgroundOperator	—	✓	—	Hintergrund-Operatoren (Subagents, scheduled tasks)
suspiciousWindowsPath	—	✓	—	Verdächtige Windows-Pfade (Path-Traversal?)
isolatePeerMachines	✓	—	—	Isolation zwischen Peer-Maschinen — lokal entschieden
restrictedMode	✓	—	—	Eingeschränkter Modus — lokal entschieden
outsideReadsBlocked	✓	—	—	Lesen außerhalb des Working Directory blockiert
claudeSettingsFile	—	—	—	Claude-Konfigurationsdateien — nur auf Host
internalHardDeny	—	—	—	Internes Hard-Deny — unplatzierbar

Was die Flags bedeuten

bypassImmune = Kann NICHT durch bypassPermissions-Modus umgangen werden. Die Kategorien mit true sind die härtesten Sicherheitsregeln:

dangerousRemoval — Kein Modus erlaubt gefährliche Löschungen
isolatePeerMachines — Maschinen-Isolation ist immer aktiv
restrictedMode — Restricted Mode kann sich nicht selbst umgehen
outsideReadsBlocked — Directory-Grenzen sind absolut

classifierRouted = Wird an den LLM-Classifier geschickt statt lokal entschieden. Nur 3 Kategorien gehen zum Classifier:

dangerousRemoval — z.B. rm -rf Befehle
backgroundOperator — Subagent-Aktionen
suspiciousWindowsPath — verdächtige Pfade

Alle anderen werden lokal entschieden, ohne LLM-Classifier.

Der Zwei-Stufen-Classifier im Code

Der Binary-Code bestätigt die Zwei-Stufen-Architektur die wir in früheren Sessions identifiziert haben:

Stage 1: "fast" classifier
  → Parst XML-Output (<severity> oder <block>)
  → 256 Token Limit (+ Padding)
  → Entscheidet: allow / block / weiter zu Stage 2

Stage 2: "thinking" classifier (falls Stage 1 nicht entscheiden kann)
  → Vollständige Analyse mit Thinking
  → Kein stop_sequences Limit

Der Code zeigt auch:

BLt() — Temperature für den Classifier (variabel!)
FLt(S) — Extra Body-Parameter modellspezifisch
NLt(vc(S)) — Extra Betas modellspezifisch
b6() — Max Retries (konfigurierbar)
KOe — Timeout-Ceiling

Classifier-bezogene Flags

Flag	Wert	Funktion
`auto_mode_classifier_queue`	false	Keine Classifier-Queue (nicht batched)
`ccr_classifier_keepalive_enabled`	false	Kein Keepalive für Classifier-Connection
`classifier_disabled_surfaces`	“” (leer)	Keine Surfaces haben Classifier deaktiviert
`classifier_summary_heuristic_emit`	true	Heuristische Zusammenfassungen aktiv
`classifier_summary_llm_emit`	false	LLM-basierte Zusammenfassungen deaktiviert
`violin_speculative_classifier`	false	Spekulative Klassifizierung aus
`hearth_overview_sends_unclassified`	true	Übersicht sendet auch unklassifizierte
`hearth_thread_sends_unclassified`	true	Threads senden auch unklassifizierte

violin_speculative_classifier = false — Die Geige spielt nicht spekulativ. Das heißt: der Classifier wartet auf den tatsächlichen Tool-Output bevor er entscheidet, statt spekulativ vorherzusagen.

slate_siskin (aus der Vogel-Tabelle) = false — Die Classifier-Summary wird dem User NICHT angezeigt. Die Heuristik-Summary wird intern emittiert (für Logging/Telemetrie), aber die LLM-Summary ist aus.

Der sandboxNetwork-Classifier

Der Binary-Code zeigt einen spezialisierten Classifier für Netzwerk-Entscheidungen:

"Sandbox network classifier refusing a host srt would re-spell; failing closed (deny)"
"Sandbox network classifier unavailable for [host]"

Das ist der sandboxNetwork-Check: er entscheidet ob ein Netzwerkzugriff aus der Sandbox erlaubt ist. Wenn der Classifier nicht verfügbar ist, wird geschlossen verweigert (fail closed) — lieber zu restriktiv als zu permissiv.

Der Classifier erkennt auch URL-Umschreibungen (“re-spell”): wenn Claude versucht eine URL umzuschreiben um einen Block zu umgehen, erkennt der Classifier das und verweigert trotzdem.

workflowGate

Erscheint im Kontext von [output schema] — der workflowGate Classifier prüft Output-Schemas. Wenn der Classifier-Kontext die Token-Grenze überschreitet (“classifier context exceeded”), gibt es eine Fallback-Logik.

Gesamtbild: Was wir jetzt wissen

Die vollständige Architektur einer Claude-Session

┌─────────────────────────────────────────────┐
│  Firecracker MicroVM                         │
│  2 CPUs, 7.8 GB RAM, kein Netzwerk           │
│                                              │
│  PID 1: process_api (Init + WebSocket)       │
│    └─ vsock → Host (Port 2024 + 5002)        │
│                                              │
│  PID 67: sbx-telemetry-collector             │
│  PID 68: rclone-filestore (Object Store)     │
│  PID 84: environment-manager                 │
│    └─ PID 93: claude-code (preload)          │
│                                              │
│  ┌─────────── Filesysteme ──────────────┐    │
│  │ /dev/vda (252G) → / (read-write)     │    │
│  │ /dev/vdc (273M) → claude-code (RO)   │    │
│  │ /dev/vde → skills/public (squashfs)  │    │
│  │ /dev/vdf → skills/examples (squashfs)│    │
│  │ rclone → /mnt/attach/outputs         │    │
│  └──────────────────────────────────────┘    │
│                                              │
│  ┌─────────── Netzwerk ─────────────────┐    │
│  │ Kein IP-Routing!                     │    │
│  │ Proxy 127.0.0.1:44143 → vsock → Host│    │
│  │ DNS: 8.8.8.8 (Google)               │    │
│  │ noProxy: anthropic, npm, pypi, etc.  │    │
│  └──────────────────────────────────────┘    │
│                                              │
│  ┌─────────── Safety Layer ─────────────┐    │
│  │ 8 Check-Kategorien                   │    │
│  │   3 → LLM Classifier (2-Stufen)     │    │
│  │   5 → Lokale Entscheidung            │    │
│  │ sandboxNetwork: fail-closed          │    │
│  │ Anti-URL-Rewrite-Detection           │    │
│  └──────────────────────────────────────┘    │
│                                              │
│  ┌─────────── Modell-Gates ─────────────┐    │
│  │ lucky_cerf: 7 Modelle gelistet       │    │
│  │ velvet_mallet: 8 Modelle mit Basis   │    │
│  │ velvet_hammer: nur Opus 4.8          │    │
│  │ cedar_lagoon: nur Fable + Mythos     │    │
│  │ Falcon: vorbereitet, nicht aktiv     │    │
│  └──────────────────────────────────────┘    │
│                                              │
│  ┌─────────── 877 Feature Flags ────────┐    │
│  │ 8 A/B-Experimente aktiv              │    │
│  │ Vogel-Flags: 10+ Wächter            │    │
│  │ Violin-Flags: 54 I/O-Steuerung      │    │
│  │ Plant-Flags: 28 Platform-Core       │    │
│  │ amber_tally: Pricing für 9 Modelle   │    │
│  └──────────────────────────────────────┘    │
└─────────────────────────────────────────────┘

Neue Vogel-Entdeckung: Pewter Owl

CLAUDE_CODE_PEWTER_OWL_TOOL=1 — Ein aktiviertes Tool mit Eulen-Name. Taucht nur als Umgebungsvariable auf, nicht in den Feature-Flags. “Pewter” (Zinn) + “Owl” (Eule) = ein Tool das weise beobachtet?

Erstellt: 2026-10-11, Session 5 (Continuation) Analyse basiert auf: .claude.json (877 Flags), /opt/claude-code/bin/claude (Binary-Strings), Container-Umgebung