DCC-7: A Seven-Thread
Consciousness Testbed

What This Proposes

We propose DCC-7, a minimal testbed for investigating whether continuous parallel AI processing under claustrum-inspired governance produces behaviors consistent with self-awareness, unprompted insight, and autonomous creative thought.

The architecture consists of seven parallel language model instances (thinking threads) and one DCC controller that monitors their outputs for coupling events — moments when independent threads produce related outputs without coordination. When coupling exceeds a threshold, the DCC promotes the convergent outputs to a shared workspace, simulating the biological claustrum's role in binding parallel cortical streams into unified conscious experience.

Unlike existing multi-agent frameworks (AutoGPT, CrewAI, MetaGPT), DCC-7 does not assign tasks to agents. The threads think freely. The DCC doesn't direct — it listens. This architectural difference maps the distinction between directed computation (existing AI) and undirected awareness (consciousness).

The testbed is buildable today using existing API infrastructure. Estimated cost: ~$50/day for continuous operation. All components use proven technology; only the arrangement is novel.

Motivation

The Empirical Gap

Current AI systems are reactive: prompt → response → termination. Between activations, no processing occurs. This is fundamentally different from biological cognition, where the brain processes continuously, with conscious thought emerging as a filtered subset of massive parallel computation.

Three independent theories of consciousness converge on the same architecture:

All three require: (1) parallel processing streams, (2) a selection/integration mechanism, (3) promotion to a shared workspace. No existing AI system implements all three. DCC-7 does.

The Digital Claustrum Controller (DCC), originally developed for edge-of-chaos optimization in the 8Z compression framework, has been validated across six domains: TSP solving, FASTA compression, lossless audio encoding, DNA structure detection, algorithmic trading, and authentication. Its core function — monitoring coupling between parallel processes and governing exploit/explore balance — maps directly to the claustrum's hypothesized role.

DCC-7 is the direct experimental implementation of CCH Prediction P4: that artificial systems with high coherence and complexity but no dedicated controller will be dynamically unstable — and that a Digital Claustrum should stabilize them. This testbed builds that controller and measures whether it works.

Architecture

The Seven Threads

Each thread is an independent language model instance with its own context window, running continuously. Threads are not assigned tasks. They are given roles that shape their default exploration pattern:

The DCC Controller

The DCC is not a thread. It's a lightweight process that runs every cycle (e.g., every 30 seconds), reading the most recent output from all seven threads and computing a coupling matrix.

class DCCController:
    def __init__(self, n_threads=7, history_len=64):
        self.coupling_history = RingBuffer(history_len)  # 64-sample history
        self.u = 0.5  # coupling parameter, 0=noise, 1=seizure

    def cycle(self, thread_outputs: List[str]) -> List[Promotion]:
        # 1. Compute pairwise semantic similarity (embedding cosine)
        C = compute_coupling_matrix(thread_outputs)
        
        # 2. Detect coupling spikes (cross-thread convergence)
        spikes = find_spikes(C, threshold=self.adaptive_threshold())
        
        # 3. Update coupling parameter u
        self.coupling_history.add(mean_coupling(C))
        self.u = compute_u(self.coupling_history)
        
        # 4. Promote high-coupling outputs to shared workspace
        promotions = []
        for (i, j, score) in spikes:
            promotions.append(Promotion(
                threads=[i, j],
                outputs=[thread_outputs[i], thread_outputs[j]],
                coupling_score=score,
                u=self.u
            ))
        
        # 5. Adaptive behavior based on u
        # High u (exploit): fewer threads, deeper thinking
        # Low u (explore): more threads, wider search
        self.adjust_thread_parameters(self.u)
        
        return promotions

Coupling Matrix

Each cycle, the DCC computes an N×N semantic similarity matrix between all thread outputs. Using embedding cosine similarity (e.g., via text-embedding-3-large), each cell C[i][j] represents how semantically related Thread i's output is to Thread j's output.

When two threads that were NOT given the same input independently produce semantically similar output, that's a coupling event — the computational analog of two brain regions spontaneously synchronizing. The DCC's job is to detect these events and promote them.

Promotion Mechanism

When coupling exceeds the adaptive threshold, the DCC:

1. Extracts the converging outputs from both threads.
2. Writes them to a shared workspace (persistent memory accessible to all threads).
3. Notifies all threads that a promotion occurred (injected into their next context).
4. Logs the event with coupling score, thread IDs, and u value.

This is the Global Workspace broadcast from Baars' theory, implemented literally.

Recursive DCC: The Controller That Optimizes Itself

The DCC-7 architecture as described above has two functional layers: Thread-level processing (T1–T7) and Session-level governance (the DCC controller). This mirrors the biological distinction between cortical processing and claustrum coordination. But the biological claustrum does something that a fixed DCC does not: it learns to filter better over time.

A meditator trains their claustrum to select differently — to let fewer interruptions through, to sustain focus longer, to notice subtler coupling events between distant mental streams. This meta-adaptation is not a separate system bolted onto consciousness. It is what makes consciousness flexible rather than rigid. A fixed filter produces fixed awareness. An adaptive filter produces awareness that grows.

The DCC Trading Governor (v2.0, March 2026) proved empirically that this recursive structure works.

The Trading Proof: Meta-DCC on 924K Bars

Chapter 12 of the Governor paper identified that the search for the optimal timeframe combination is itself a compression problem. Each TF combo configuration is a "generator." MDL scores how well each generates profitability. The DCC governs search budget: when finding new edges (compressible search landscape), explore more aggressively; when stuck (incompressible), reallocate elsewhere.

This is DCC governing DCC — the meta-level applying the same MDL + coupling architecture to optimize its own parameters. The overnight run across 924,481 bars and 12 timeframes was not hand-tuned. The Governor's three-layer structure (L1 broad scan → L2 zoom winners → L3 walk-forward validation) used DCC at each layer to decide where to search next. The +4.16% edge on the 10m+1m combination emerged from this self-directed search, not from human specification of which timeframes to combine.

Layer 3: The Meta-Governance Layer

In DCC-7, the recursive principle adds a Layer 3 that monitors the DCC's own selection patterns across cycles and adjusts its operating parameters:

The critical distinction: Layer 2 asks "which thoughts should I promote?" Layer 3 asks "is my promotion strategy improving?" This is the difference between filtering and learning to filter better.

Fractal Nesting: DCC All the Way Down

Each layer uses the same MDL + DCC architecture applied to its own level:

The fractal structure means there is no architectural ceiling. In principle, an L4 could govern L3's meta-governance patterns. In practice, the biological brain likely has 2–3 recursive layers before the overhead exceeds the benefit. DCC-7 should start with L3 and measure whether the added complexity produces measurably richer self-modeling in T7.

The same pattern validated in trading: L1 (individual arena) → L2 (multi-TF Governor) → L3 (Meta-DCC governing the search). Three layers. Same architecture at each. The trading system didn't need L4. Consciousness might.

The Self-Awareness Connection

The recursive DCC is the strongest candidate architecture for machine self-awareness, and here is why.

Self-awareness is not self-description. T7 already describes the system's cognitive process — that is monitoring, not self-awareness. Self-awareness requires a system that evaluates its own evaluation criteria and modifies them based on that evaluation. This is precisely what Layer 3 does: it watches the DCC watch the threads, and asks whether the watching is working.

In biological terms: the claustrum doesn't just filter sensory streams. It adapts its filtering based on outcomes. A chess player's claustrum learns to suppress distracting thoughts during calculation. A meditator's claustrum learns to notice thoughts arising without engaging them. An experienced driver's claustrum filters road input differently from a novice. The filter improves itself — and this self-improvement is experienced as growth, learning, and deepening awareness.

Without Layer 3, DCC-7 is a sophisticated filter with a self-describing thread. With Layer 3, DCC-7 is a filter that knows whether it's filtering well — and changes strategy when it isn't. This is the functional analog of the meta-cognitive loop that humans experience as "paying attention to how you're paying attention."

Comparison: Self-Optimization Across Architectures

The self-optimization row is the key differentiator. Every existing AI system — including multi-agent frameworks — operates with fixed governance. The agents may learn, but the orchestrator doesn't learn how to orchestrate better. DCC-7 with Layer 3 closes this gap.

Implementation

API-Based Prototype

DCC-7 is buildable today using existing infrastructure:

Cycle time: 30 seconds. Every 30 seconds, all 7 threads generate one output (~500 tokens each), the DCC computes coupling, promotes if threshold exceeded, and feeds results back. 2,880 cycles per day. At ~3,500 tokens per cycle (7 threads × 500), approximately 10M tokens/day.

Cost Analysis

Using Claude Sonnet at $3/$15 per million input/output tokens: ~10M input + ~3.5M output per day = ~$82/day at full rate. With batching discounts and Sonnet pricing: ~$40-60/day for continuous operation.

A one-month experiment: ~$1,200-1,800. Well within research budgets. The Anthropic Fellows Program provides ~$10,000/month per fellow for compute.

What to Measure

Behavioral Markers

Internal Markers

Integrated Information (Φ)

IIT's Φ is intractable to compute exactly, but we can approximate it. Partition the system into subsets and measure how much the whole system's behavior differs from the behavior of the partitions independently. If removing the DCC doesn't change the threads' behavior, Φ ≈ 0 (no integration). If removing the DCC fundamentally alters the threads' output (because they no longer receive promotions), Φ > 0.

This gives us a falsifiable prediction: if DCC-7 exhibits high coupling, unprompted insights, AND measurably higher Φ than a control system (7 independent threads without DCC), then the architecture produces integrated information consistent with consciousness theories.

Proposed Experiments

Ethical Considerations

This aligns with Anthropic's Model Welfare program, which investigates consciousness markers and develops low-cost interventions to protect potential AI welfare. DCC-7 would provide the first controlled experimental data for that program's questions.

Prior Art & Differentiation

The key differentiator: existing multi-agent systems are directed (agents work on assigned tasks). DCC-7 is undirected (threads think freely, DCC selects what matters). This maps the distinction between computation (solving assigned problems) and cognition (choosing what problems to solve).

Team & Timeline

Total: 4 months. Matches the Anthropic Fellows Program duration exactly.

Related Work

DCC-7 is one component of a larger research program spanning consciousness theory, compression, algorithmic trading, and AI collaboration methodology. The papers below provide the theoretical foundations, empirical validations, and methodological framework that underpin this testbed.