Technical Overview

The Tribunal Governance Engine

The Tribunal is a self-improving orchestration framework for autonomous decision-making through hierarchical accountability. It is formally called Ancestral Tribunals: each generation inherits the verified record, but only evidence that survives the truth layer earns authority.

read-only governance stream

Sanitized Tribunal Trace

The Inversion

t+00s[INGEST]market-state packet sealed; public surface redacted

t+07s[ENGINE-R]daily target weights generated; execution authority separate

t+14s[ENGINE-C]candidate book in development; no authority granted

t+21s[SENTINEL]regime mandate attached; capital posture checked

t+28s[PROPHET]computed brief attached; counsel remains probationary

t+35s[KING]allocation gate compared against deterministic control

Why Hierarchy — The Flat System Problem

Most multi-agent systems place agents at the same tier: a main agent, a set of advisors, all voting together. The problem is structural. When every voice occupies the same level, disagreement has no resolution mechanism. Unanimous wrong answers become the output. Bias aggregates instead of canceling.

The Tribunal’s hierarchy exists because each tier solves a problem the tier below it should not own:

Tier	The problem it solves
Deterministic engines	Trading authority must begin with auditable systems, not persuasive narratives.
Shadow candidates	New claims need a safe lane where they can be tested without touching authority.
Prophet + Sentinel	The court needs verified context and a regime conscience before capital is committed.
King	Allocation and stand-down decisions require portfolio-level synthesis, not raw signal output.
Succession institution	No governor should keep a seat after a challenger proves superior.

Each layer is a correction of the layer below’s structural blindspot — not a redundancy.

Architecture Philosophy

Three core principles underpin everything:

Separation of powers — trading, context, allocation, safety, and verification are different jobs.
Hardware-aware inference — deterministic code handles repeatable trading logic; large models are reserved for deliberation and synthesis.
Self-improving lineage — verified outcomes become the institutional record for the next generation.

1. The Two Triumvirates

Trading Triumvirate — Python Engines

The trading layer is deterministic and auditable. Engines produce target outputs that can be replayed, measured, and compared. Public documentation names the seats without disclosing private construction details.

Reversal Engine — active daily target generation.
Carry Engine — funding and basis research path.
Trend Engine — longer-horizon path gated before build.

This layer is not a collection of model personalities. It is the measurable substrate the governing court must beat.

Governing Triumvirate — LLM Court

The governing layer is where models belong first: synthesis, context, challenge, allocation, and stand-down reasoning.

King — capital allocation and sizing governor.
Prophet — verified context and structured counsel.
Sentinel — regime and capital-danger conscience.

All three are probationary. They hold authority only where measured contribution justifies it.

Retired Origin Seats

The original LLM signal seats remain part of the project’s history. They proved an important law: a beloved architecture must still submit to measurement. Their retirement is not hidden. It is evidence that the system can demote its own assumptions.

2. The MoE Parallel

A deliberation model may use a Mixture-of-Experts architecture — a large pool of specialist subnetworks with only a small subset active on each forward pass. Every inference call is already a small tribunal: route, select, silence, synthesize.

The Tribunal applies that pattern at the system level while refusing to force the model into jobs better owned by deterministic code.

3. Inference Architecture

The system runs two permanently separated tracks:

Trading Track — deterministic Python engines, auditable target generation, replayable outputs, cost-aware evaluation, and frozen controls.

Deliberation Track — thinking-capable models for allocation, synthesis, context, and governance. Sequential, not parallel by default. Compute is reserved for the decisions where reasoning might add measured value.

A trading engine is not promoted into a governor because it produces returns. A governor is not allowed to trade because it is articulate. The tracks serve different functions and are built differently from the start.

4. The Verified Lineage

The Cycle

Market state → Engine output → Governance decision → Result ledger
                    ↓                 ↓
             Frozen control      Paired comparison
                    ↓                 ↓
             Canon update ← Verified outcome

Each cycle preserves the separation between raw engine output, model governance, final action, and market result. That separation lets the system know whether a model improved the decision or merely changed it.

Verified learning loop

Engines, governors, and candidates are separated until measured results justify authority.

The Canon

The Canon is what survives after every model generation is retired.

When an architecture is replaced entirely — all adapters discarded, all weights gone — the Canon survives. Verified principles, confirmed regime behaviors, and operating law remain. The next generation inherits institutional memory even if it inherits no weights.

Canon grows only when Python agrees. The Prophet proposes a claim. The Scribe normalizes it. Python verifies it against the recorded tablets. Only then does it enter Canon as Law.

Prophet observes → Scribe normalizes → Python verifies → Canon records

5. Natural Selection

The system is designed to evolve — not toward a predetermined final form, but toward measured usefulness.

Every component carries a fitness record derived from outcomes. When a candidate outperforms an incumbent under the same replay and risk rules, the candidate can advance. When a seat stops contributing, it is demoted or retired.

This applies at every layer:

Engines — candidate systems audition before authority.
Governors — King, Prophet, and Sentinel keep authority only through measured contribution.
Adapters — tested against replay buffers and behavioral consistency gates.
Canon — patterns that stop holding are reclassified, not preserved out of inertia.

The initial system is dictated by the founder. The final system is forever evolving, shaped by evidence alone.

6. Infrastructure

Watchdog systems — automated monitors detect stalls and trigger recovery.
No lookahead — replay and evaluation use only data available at decision time.
Consensus-governed execution — actions execute only when the governing chain permits exposure.
Hardware-aware inference — deterministic systems for repeatable trading logic; thinking models for deliberation.
Private implementation details — thresholds, feature construction, prompts, model weights, and labeling logic are not public material.