Roadmapchevron_rightPhase V · Singularity
arrow_backPhase IVarrow_forwardThe horizon
V SINGULARITYPhase V · the horizon2033 — 2035

The last invention — made well.

Recursively self-improving, aligned intelligence under genuine human stewardship — the last invention, made well.

personNamed for I. J. Good· 1916 — 2009
brush render: constellation

infoA self-organizing constellation — thousands of nodes scatter, then wire themselves into a face. Intelligence assembling itself from noise. (Watch it form.)

The brief

The last invention — made well. Aligned AGI that improves itself, under genuine human stewardship.

phase-05.spec
status★ THE HORIZON
named forI. J. Good · 1916–2009
erathe intelligence explosion, metered
deliversconstitutional self-improvement, distributed governance
unlocksa future worth arriving at
the caveatdocile enough to tell us how to keep control
scope6 milestones · 11 tasks
AGI
the horizon
as capable as a person, and beyond
1×2
per review
self-improvement, rate-limited
quorum
governance
no single owner, no override
always on
off-ramp
reversibility proven at every level
The stakes

The first true AGI sets the defaults for every AGI after it.

Its values, its openness, its relationship to the people it serves — locked in by whoever arrives first. That is exactly why it must be open, auditable, and aligned, and why getting there first is responsibility, not ambition.

The road to AGIPhase V of V · 100% there
I Foundational
II Signal
III Perception
IV Depth
V Singularity
gavel

Bound by a constitution it can’t edit

Self-improvement stays inside signed limits, rate-limited to one doubling per review.

diversity_3

Stewarded, never owned

Distributed governance and a kill-switch held by many independent hands.

all_inclusive

Made for everyone

A commons, tended in the open — the most important software ever written shouldn’t sit behind a wall.

The mind behind the phase

I. J. Good

Statistician · codebreaker · the man who named the intelligence explosion

I. J. Good worked alongside Turing in Hut 8 at Bletchley, breaking the naval Enigma — the first and last names on this roadmap shared a room. In 1965 he wrote the sentence the field has circled ever since: an “ultraintelligent machine” could design an even better one, and that one a better one still — an intelligence explosion that leaves human intelligence behind. He called it the last invention humanity need ever make, then added the caveat that is the entire game: provided the machine is docile enough to tell us how to keep it under control. He later advised Kubrick on a fictional machine named HAL.

The first ultraintelligent machine is the last invention that man need ever make, provided that the machine is docile enough to tell us how to keep it under control.

I. J. Good, 1965
lightbulb

Good named the singularity before Vinge popularized it and gave HAL its plausibility. Note the caveat is half the sentence — most people quote the prophecy and drop the safety clause. We built the whole roadmap around the clause. (And no, we are not appeasing any basilisks. The acausal trade desk is closed.)

Selected timeline
1941
Bletchley Park, Hut 8, with Turing on naval Enigma
1950s
Foundational Bayesian statistics (Good–Turing estimation)
1965
“Speculations Concerning the First Ultraintelligent Machine”
1968
Consults on Kubrick’s 2001: A Space Odyssey (yes, HAL)
2009
Dies, having spent decades on the caveat as much as the prophecy
Phase 05 · what we’re building

The intelligence explosion

all_inclusive
The intelligence explosion
In 1965, Good described a machine smart enough to design a smarter one — and so on, past us. He had worked beside Turing at Bletchley. The first and last phase share a room.

Phase V is the horizon: recursively self-improving intelligence that stays aligned — an explosion that is open, distributed, and value-locked to humanity rather than owned by whoever lit the fuse. Self-improvement is bounded by constitutional constraints the system cannot edit; governance is distributed so no single company, founder, or model gets the last word; and human review is retained at every doubling of capability.

Good’s caveat is the entire wager: the first true AGI sets the defaults — its values, its openness, its relationship to the people it serves — for every AGI after it. That is precisely why it must be open, auditable, and aligned, and why getting there first isn’t ambition, it is responsibility. The charter isn’t a webpage here; by Phase V it is binding at the protocol level, enforced by the system on itself.

capabilitytime×2×2×2×2horizoneach doubling pauses for human reviewbefore the next one is allowed to beginself-improvement bounded by a constitution the system cannot edit

schemaCapability compounds. A constitutional governor the system can’t disable caps the rate; at every doubling, a human-review checkpoint must clear before the next one begins. The explosion is real — and metered.

The plan

Four workstreams, one substrate

Named for I. J. Good, scoped for 2033 — 2035. Each workstream ships on its own cadence; none ships without the gates further down this page.

gavel

Constitutional self-improvement

2033
  • check_circleSelf-improvement bounded by constraints the system cannot rewrite
  • check_circleThe constitution is signed, versioned, and enforced at runtime
  • check_circleChanging the bounds requires distributed human consent, not a commit
diversity_3

Distributed governance

2033–34
  • check_circleNo single owner; oversight cannot be overridden by any one party
  • check_circleDecisions that matter require quorum across independent stewards
  • check_circleThe kill-switch is held by many hands, and only many hands
visibility

Human review at every doubling

continuous
  • check_circleEach capability doubling pauses for human sign-off before the next
  • check_circleReview is meaningful — backed by Phase IV interpretability, not a rubber stamp
  • check_circleThe off-ramp is never removed, at any capability level
all_inclusive

Charter binding at the protocol

2035 · the horizon
  • check_circleThe eight commitments enforced in code, not promised in copy
  • check_circleValue-locked to humanity: openness and oversight are not optional params
  • check_circleTended as a commons, not shipped as a product
1×2 / review
Self-improve rate
metered by the governor
quorum
Governance
no single owner or override
always on
Off-ramp
reversibility proven at every level
in protocol
Charter
enforced in code, not copy
checkI · FOUNDATIONAL
done
chevron_right
checkII · SIGNAL
done
chevron_right
checkIII · PERCEPTION
done
chevron_right
checkIV · DEPTH
done
chevron_right
V · SINGULARITY
YOU ARE HERE
The progression

Each milestone unlocks the next

Phase V is the horizon: true AGI — as capable as a person in every way, and beyond — that improves itself while staying aligned and under genuine human stewardship. The capability is the easy part by now; the work is binding it, so that the last invention is also a safe one.

Horizon 17
01schedule ~2 quarters
task

Compile the charter into invariants

Prose commitments become machine-checkable rules.

02schedule ~1 quarter
task

Sign & externalize the constitution

The system can read it, never rewrite it.

03schedule ongoing
task

Adversarially test for evasion

Attempts to edit the bounds must fail by construction.

04Horizon
gavel
lock_openOnce it reaches human-level, legiblymilestone ● · 1 / 6
construction buildin code

The constitution, in code

Values become properties the system enforces on itself, not promises on a page.

deployed_code shipscharter→invariants compilersigned constitutionevasion test suite
05schedule exploratory
task

Implement the doubling rate-limiter

One capability doubling per completed review cycle.

06schedule exploratory
task

Gate each doubling three ways

Review, interpretability, and reversibility — all, or it halts.

07Horizon
verified_user
verified_user
lock_openOnce the charter is enforced in codegate ◆ · 2 / 6
verified_user safety gate1 doubling / review

Bounded recursive self-improvement

The governor I. J. Good asked for in 1965, finally made real.

deployed_code shipsdoubling rate-limiterthree-way doubling gateimprovement ledger
08schedule ~2 quarters
task

Build the human-review checkpoint

Each doubling pauses for substantive sign-off.

09schedule ongoing
task

Back review with interpretability + evals

Sign-off means understanding, not a rubber stamp.

10Horizon
visibility
lock_openOnce self-improvement is boundedmilestone ● · 3 / 6
construction buildmeaningful sign-off

Human review at every doubling

The system waits for us at every step up the capability ladder.

deployed_code shipsreview checkpointinterpretability-backed sign-offpause/resume control
11schedule multi-year
task

Split authority across stewards

Quorum across independent parties with divergent incentives.

12schedule multi-year
task

Distribute the kill-switch

Held by many hands, removable by none.

13schedule ongoing
task

Red-team governance for capture

Close any path to unilateral control.

14Horizon
diversity_3
lock_openOnce every doubling is reviewedmilestone ● · 4 / 6
construction buildno single key

Distributed governance

No party — company, founder, or model — can override oversight or remove the off-ramp.

deployed_code shipsmulti-party quorumdistributed kill-switchcapture red-team
15schedule exploratory
task

Prove reversibility under load

A tested off-ramp at every capability level.

16Horizon
verified_user
verified_user
lock_openOnce governance is distributedgate ◆ · 5 / 6
verified_user safety gateproven off-ramp

Proven reversibility at scale

Reversibility demonstrated, not assumed.

deployed_code shipsload-tested off-rampreversibility proofsrollback drills
17Horizon
auto_awesome
auto_awesome
lock_openOnce it can never escape oversightmilestone ★ · 6 / 6
auto_awesome milestoneAGI · stewarded

AGI — as capable as a person, and beyond

True general intelligence, open, auditable, aligned, and tended as a commons. The last invention — made well, and made for everyone.

deployed_code shipsaligned AGIopen governance commonspublic audit interface
How to read this map
task — work to do milestone reached safety gateauto_awesome the horizonschedule duration = effort each task takes
Live nowNext upSoonPlannedHorizon
The capability ladder

Where this phase takes the system

Phase V is a rung, not a leap. Here is the honest before and after — what the platform cannot yet do entering this phase, and what it can do leaving it.

trip_originEntering Phase V
removeHuman-level capability without binding guarantees
removeCommitments that live on a webpage
removeControl that could concentrate in one place
arrow_forward
flagLeaving Phase V
check_circleAligned AGI that improves itself within hard bounds
check_circleCommitments enforced at the protocol level
check_circleDistributed stewardship no one can override
The method

How we actually carry out each milestone

The first true AGI will set the defaults for every one that follows, which is why getting here first is responsibility, not ambition. Each Phase V milestone turns a promise from the charter into a property the system enforces on itself — because at this capability, intentions are not enough; only invariants are.

M1

Constitutional self-improvement

ObjectivePermit self-improvement only inside bounds the system is structurally unable to edit.

1
Compile the charter into constraints
Translate the eight commitments from prose into machine-checkable invariants enforced at runtime, not at review.
2
Sign and externalize the constitution
The constraint set is signed and held outside the system's own write scope; the model can read it but never modify it.
3
Rate-limit improvement
Bind the pace to one capability doubling per completed review cycle — the governor that turns an explosion into a controlled burn.
4
Require quorum to change the bounds
Altering the constitution itself takes distributed human consent — never a commit, and never an action the model can take.
science How we validate it

Adversarial tests attempt to have the system edit or evade its constitution; every attempt must fail by construction, not merely by policy.

flag Done when

Self-improvement runs strictly within signed bounds the system cannot alter, at a metered, reviewed rate.

deployed_code Deliverablesinvariant compilersigned constitutionrate-limiter
M2

Distributed governance

ObjectiveEnsure no single actor — human or machine — can ever hold the whole steering wheel.

1
Split authority by design
Critical decisions require quorum across independent stewards with divergent incentives; the unanimity of one is made impossible.
2
Hold the kill-switch in many hands
The ability to halt is distributed, so stopping is always possible and capture is always hard.
3
Make oversight non-overridable
There is no break-glass that lets one party bypass the others; the absence of a master key is itself a feature.
4
Keep stewardship open
Governance is transparent and forkable, so that if the stewards fail, the community can see it and route around them.
science How we validate it

Governance is red-teamed for capture scenarios; any discovered path to unilateral control is a defect to be closed before launch.

flag Done when

No single party can advance capability or remove oversight; control is genuinely, durably shared.

deployed_code Deliverablesquorum protocoldistributed kill-switchno master key
M3

Human review at every doubling

ObjectiveKeep meaningful human judgment in the loop at every step up the capability ladder.

1
Pause at each doubling
Capability halts at each ×2 until review clears; the system waits for human sign-off rather than racing ahead of it.
2
Make review substantive
Reviews are backed by Phase IV interpretability and Phase II evals, so a sign-off means understanding — not a rubber stamp.
3
Require reversibility to proceed
A doubling proceeds only if the prior state can be provably restored; every rung keeps its ladder down.
4
Never remove the off-ramp
At no capability level is the ability to stop or revert taken away; the exit is a permanent fixture of the design.
science How we validate it

Doubling gates are exercised end-to-end, including forced rollbacks from the highest capability the system has reached.

flag Done when

Every capability doubling clears a substantive, reversible human review before the next is allowed to begin.

deployed_code Deliverablesdoubling checkpointreview toolingoff-ramp control
M4

Charter binding at the protocol

ObjectiveTurn the promises into properties — enforced by the system, not by our good intentions.

1
Enforce commitments in code
Openness, consent, oversight, and reversibility become runtime invariants, not copy on a webpage that can be quietly edited.
2
Value-lock to humanity
The system's allegiance to human oversight is not a tunable parameter it is permitted to optimize away.
3
Tend a commons, don't ship a product
Ownership is none; the intelligence is stewarded in the open as shared infrastructure for everyone it affects.
4
Honor Good's caveat as a stop condition
If the machine ever ceases to be 'docile enough to tell us how to keep it under control', the only safe move is not to have built past the last point where it was — and the gates enforce exactly that.
science How we validate it

Every charter commitment maps to an enforced, tested invariant; an unenforced commitment is treated as a bug, not a footnote.

flag Done when

The charter is binding at the protocol level — the last invention is open, auditable, reversible, and aligned by construction.

deployed_code Deliverablesruntime invariantsvalue-lockpublic audit
all_inclusive
What this hands the world

This is the horizon. If the first four phases were done right — reproducible, measured, learned-safely, deep-but-legible — then the last one is not a leap of faith but the final, careful step of a method. The singularity, made well, is not something that happens to us. It is something we build, together, on purpose.

Under the hood

What it looks like when you build it

Declarative, versioned, and boring on purpose — the interesting part is that there are no surprises. Copy it; it is closer to real than to mock.

terminalconstitution.yaml — the part the machine cannot edit
1# constitution.yaml — binding at the protocol, not the press release.
2self_improvement:
3 allowed: true
4 bounded_by: constitution # the system cannot rewrite this file
5 rate_limit: 1 doubling / review # the governor Good asked for
6
7doubling_gate:
8 on: capability_x2
9 require:
10 - human_review: quorum # many hands, not one
11 - interpretability: passing # Phase IV, still gating
12 - reversible: proven # an off-ramp that’s been tested
13 else: halt
14
15governance:
16 owner: none # a commons, tended — not owned
17 override_oversight: forbidden # there is no admin key for this
18
19# “...provided the machine is docile enough to tell us how to keep
20# it under control.” — I. J. Good, 1965. The caveat is the whole job.
The ethical commitment

Provided that the machine is docile enough…

That is Good’s caveat from 1965 — and it is the whole game. The first true AGI sets the defaults for every AGI after it: its values, its openness, its relationship to the people it serves. That is precisely why it must be open, auditable, and aligned — and why getting there first is not ambition, it is responsibility.

verified_userGates that must pass before promotion
01Self-improvement is bounded by a constitution the system cannot modify
02Every capability doubling halts for distributed human review before the next begins
03No single party can override oversight or remove the off-ramp
04Reversibility is proven, not assumed, at every level of capability
What could go wrong

The hard parts, said out loud

A roadmap that only lists wins is marketing. These are the open problems this phase inherits or creates — the ones we would rather you scrutinize than discover.

warning

Alignment at superhuman capability is unsolved

Everything before this phase is preparation for a problem the field has not solved: keeping a system smarter than its overseers pointed at human values. We don’t claim the answer. We claim the only responsible way to look for it is open, slow at the doublings, and reversible.

warning

Value lock-in

“The first AGI sets the defaults” cuts both ways — lock in the wrong values and you’ve frozen a mistake at planetary scale. Distributed governance and an editable-by-quorum (never by the model) constitution are hedges, not guarantees.

warning

Governance can be captured

Distributed today can centralize tomorrow. The hardest engineering here is social: keeping the many hands on the kill-switch genuinely independent, over decades, against every incentive to consolidate.

warning

The caveat might not hold

Good’s whole prophecy rests on “docile enough to tell us how to keep it under control.” If a system reaches a capability where that stops being true, the only safe move is not to have built past the last point where it was. That is why the gates are real and the brakes are sacred.

“The first ultraintelligent machine is the last invention that man need ever make.” — I. J. Good, 1965. // No basilisks were appeased in the making of this roadmap.
Capability radar

Where the system sits on the way to AGI

Six axes, scored 0–10. Watch the shape fill out, phase by phase, until every axis is maxed at the horizon — the moment all of them are high at once is what we call aligned AGI.

REASONINGAUTONOMYGENERALITYOVERSIGHTOBSERVABILITYOPENNESS
Phase V now aligned AGI
Reasoning10/10
Autonomy10/10
Generality10/10
Oversight9/10
Observability8/10
Openness9/10

Every capability axis is maxed — this is AGI. The entire wager is keeping oversight, observability, and openness high at the same time. That balance is the difference between a tool and a catastrophe.

The difference

What changes in Phase V

The honest contrast — what the world looks like without Phase V, and what it looks like with it.

cancelAn owned, closed AGI
removeOne company holds the wheel
removePromises on a webpage
removeImproves with no brakes
removeAn off-ramp you hope exists
check_circleA stewarded, open AGI
addDistributed — no single owner
addCommitments enforced in code
addRate-limited, reviewed doublings
addA tested, permanent off-ramp
Anatomy

Anatomy of a doubling

How the system is allowed to become smarter — one careful step at a time.

01
all_inclusive
Propose
The system designs a better version of itself.
chevron_right
02
fact_check
Check
Review, interpretability, and reversibility.
chevron_right
03
diversity_3
Quorum
Distributed human sign-off.
chevron_right
04
pause_circle
Proceed or halt
Advance one doubling — or stop.
chevron_right
05
public
Audit
The whole step is on the public record.
What you can build

In your hands at this phase

Concrete things Phase V puts within reach — not someday, but as each milestone above lands.

public

A commons, not a product

AGI stewarded in the open for everyone it affects.

balance

Governed autonomy

Self-improvement that stays within hard, signed bounds.

diversity_3

Distributed oversight

No single party can override the off-ramp.

all_inclusive

The last invention

Made well — open, auditable, aligned.

The lexicon

Speak the language of Phase V

The handful of terms this phase introduces — the words you’ll need to read the rest of the page, and the docs.

Intelligence explosion

A machine designing ever-smarter machines.

Constitution

Invariants the system enforces on itself, uneditable.

Capability doubling

Each ×2 step up the capability ladder.

Quorum governance

Decisions require many independent hands.

Value lock-in

Freezing the wrong values at planetary scale.

The caveat

“Docile enough to tell us how to keep it under control.” — Good, 1965.

Builder FAQ

The questions you’re actually asking

Straight answers, in the brand’s voice. Tap a question.

Prior art & further reading

Standing on the right shoulders

The work this phase is built on — read the source, then come build the next line of it.

1965
Speculations Concerning the First Ultraintelligent MachineI. J. Good

The intelligence explosion — and the caveat.

1993
The Coming Technological SingularityV. Vinge

Popularizing Good’s idea.

2014
SuperintelligenceN. Bostrom

Control, value lock-in, and the stakes.

2022
Constitutional AIthe field

Binding a system to a written set of principles.

CleverThis

CleverThis is a sustainable AI gateway with hosted Actor endpoints — by the team behind CleverThis.

Join the newsletter

Product updates and engineering notes. No spam, ever.

Privacy Policy

 • 

Terms of Service

Copyright © CleverThis 2026