Dialogue · Schemes

Three schemes for generating multi-character dialogue.

Each scheme is a distinct theoretical position on how a conversation between two characters should be made — not just an implementation choice. The three together let an experiment ask: does isolation between actor contexts actually produce more faithful dialogue than a single LLM with access to everything? See the methodology for the full spec.

Scheme 1 python

Two brains and a robot.

Two LLM minds, each blind to the other. A deterministic robot in the middle, ferrying messages.

Actor A — LLM context Anthropic API · conversation A sees only: • actor system prompt • A's profile • A's journal • A's scene brief produces <thinking> + <speech> Actor B — LLM context Anthropic API · conversation B sees only: • actor system prompt • B's profile • B's journal • B's scene brief produces <thinking> + <speech> isolation wall Python coordinator — no LLM routes <speech> · strips close marker · logs verbatim · detects close

Two separate LLM contexts — one per character, each its own Anthropic API conversation ID — generate the actors' turns. A pure-Python coordinator routes between them, with no LLM mind of its own. The robot can't paraphrase, can't carry context, can't echo phrasing: it has no language model to do those things with.

Isolation is mechanical and total at the coordinator layer. Any contamination found in the resulting dialogue can only have come from the LLM models themselves — not from a leaky coordinator. That makes scheme 1 the cleanest test of isolation as a structural guarantee.

Runs from CLI via lib/run_dialogue.py Uses Anthropic API tokens (prompt caching helps) Most reproducible
Scheme 2 subagent

One actor in many disciplines.

One underlying model, forced into three separate disciplined contexts — a coordinator and two method-actors who have never met.

Parent CC session user's window · spawns 3 sub-agents spawns Coordinator CC sub-agent · cold context reads: • coordinator/system-prompt.md • scheme + run-meta brief never reads: ✕ either actor's profile ✕ either actor's journal ✕ either actor's brief ✕ coordinator-notes discipline by isolation Actor A CC sub-agent · same model reads: • actor system prompt • A's profile • A's journal • A's scene brief never reads: ✕ B's anything ✕ coordinator-notes in character — method-actor Actor B CC sub-agent · same model reads: • actor system prompt • B's profile • B's journal • B's scene brief never reads: ✕ A's anything ✕ coordinator-notes in character — method-actor coordinator routes <speech> between actors · strips close marker · logs verbatim

The underlying LLM is the same model in all three roles. The split is not by mechanism — it's by spawn-time context isolation and system-prompt discipline. Each sub-agent comes up cold, reads only its own materials, and never sees the others.

This is the most natural test of whether method-acting works for an LLM. The same intelligence that could write both sides at once is asked, instead, to inhabit one role per context — and to forget what it knows about the other. The coordinator sub-agent enforces the dumb-pipe rules; the two actor sub-agents enforce the in-character discipline.

Runs from a CC session Three sub-agent contexts, one shared model Covered by the CC subscription
Scheme 3 monolithic

One writer, both sides.

A single LLM with full access to everything writes the entire script in one shot. The null hypothesis given concrete form.

Inputs — all visible to one LLM no isolation actor/system-prompt.md (discipline rules applied to both sides) A's materials profile · journal · scene brief A's private locked facts: visible B's materials profile · journal · scene brief B's private locked facts: visible ONE LLM no per-turn routing · no isolation writes the whole dialogue in one pass Output: complete dialogue, one shot <turn from="..."> ... </turn> × N · ending in *[end of scene]*

One LLM, with full access to everything — both profiles, both journals, both briefs, the actor system prompt — writes the entire dialogue in a single pass. There is no isolation between roles. The single mind is asked to inhabit both characters simultaneously and produce the turns in sequence.

This is the project's null hypothesis given concrete form. The framework's central claim is that isolation produces more faithful conversation than monolithic generation; scheme 3 makes that claim falsifiable. Scheme 3 is expected to exhibit the contamination patterns the rest of the framework was built to prevent — cross-character echoing, intent-leakage, chorus-second-speaker, profile-data-as-transcript-data. The audit catches them, and the comparison against schemes 1 and 2 becomes empirical evidence.

Runs from a CC session One sub-agent, single pass The control condition

At a glance

The three schemes vary along a single axis — how much one mind sees. Reading left to right is reading from minimal-isolation to maximal-isolation.

3 · monolithic 2 · subagent 1 · python
Number of LLM contexts 1 (sees everything) 3 (1 coord + 2 actors) 2 (actors only)
Coordinator None per se — the generator is the whole pipeline LLM sub-agent (cold context, discipline rules) Deterministic Python — no LLM
Isolation between actors None Structural — separate CC contexts Structural — separate API conversations
Per-turn routing No (single pass) Yes (LLM coordinator routes) Yes (Python routes)
Journal-write step No (no character to step out of) Yes (each actor reflects) Yes (each actor reflects)
Where it runs CC session CC session CLI · lib/run_dialogue.py
Cost Cheapest — CC subscription, one sub-agent CC subscription, three sub-agents Anthropic API tokens
What it tests What contamination looks like with no isolation — the control Whether method-acting works for one underlying LLM Whether mechanical isolation is enough to produce faithful dialogue