If authority is the hard problem,
who eventually gets it?
The home page argues prediction is easy and authority is hard. The discipline that follows is governed delegation: every authority over capital enumerated, the machine allowed to act only in the safe direction, each increment of its authority priced in verification an outsider can reproduce, and the door to self-granted authority welded shut. The rest of this page is that discipline's hardest test — how far it lets authority move off a human at all — and a cold account of where that is.
A staircase, not a switch
The hardest version of the question is whether authority can leave the human at all. If it ever does, it is not one decision; it is three, taken years apart. One: the intelligence proposes and a human arms — where this is today. Two: an independent observer learns what the human actually approves and rejects, and why. Three: a separate safety intelligence, checked by the one that proposes and unable to act alone, holds the arming authority, and the human steps out.
No step is taken on confidence. Each is paid for in verification an outsider can reproduce — the gate re-executed off-box and diffed byte for byte, the arming rules property-tested over a generated input space, an off-box adversary that can only refute. Authority moves up only through those, never because the operator feels ready. The mechanics, with file and line, are on the boundary and the oversight pages.
The door that stays welded
One authority is classified permanently human-only and hard-excluded from every automatic path: the surface that would let a machine grant itself live authority. A system built to eventually delegate is only safe if it cannot delegate to itself — the exit cannot be taken without a human opening the door. Today the machine may only tighten its own guardrails and shrink its own sizing inside a human-armed envelope. It cannot open live, expand exposure, or unseal that door.
Where this actually is — cold
Stage one and a half. What decides trades today is rules and statistics, not a learned intelligence; no language model moves live capital. The autonomous parts are deterministic and small — tightening guardrails, shrinking sizing, promoting a strategy toward live only on realized, significance-tested results, always reversibly. Stage two is not built. Stage three is sealed.
And the admission that matters most. The largest risk is the single operator: the dead-man watch pages a human, it does not liquidate — because a machine that could liquidate on its own is the exact authority this design withholds.
And a line about scope. This site argues the system will not lose the money to a bad arm or a boundary bug; it says nothing about whether the strategies make money. That is deliberate. The edge — returns, alpha, out-of-sample performance — is out of scope here by design: this is a governance architecture, not a track record. “Show me the returns, not the guardrails” is a fair question, and a different one than this page answers. We would rather prove a boundary than assert a return.
Why it is worth doing at all
Trading is only the sharpest test case, and delegating to a machine only its sharpest sub-case. The discipline underneath — governed delegation: enumerate every authority, automate only the safe direction, price each increment of authority in reproducible verification, and weld the self-approval door shut — is the shape of every place we will soon want more capability without more unchecked authority, machine or human. It is a worked example of how you hand a high-stakes system to something you do not yet trust: slowly, reversibly, and never all at once.