Everything starts here. Phase I is the substrate the other four phases are built on — the command center for the agent era, shipping now.
Before a single clever thing happens, the stack has to be legible, versioned, and reversible. Phase I makes the whole machine readable while it’s still safe to read — so every phase after it can be governed.
Four phases of intelligence get built on this substrate. Get it wrong and nothing above it is trustworthy.
Apache-licensed and self-hostable, because power you can’t inspect is power you can’t trust.
This is not a someday roadmap entry — v1.0 is in your hands this week.
Mathematician · codebreaker · the man who defined the word "computer"
Alan Turing didn’t build the first computer so much as prove one could exist. His 1936 universal machine showed that a single device, given the right instructions, could compute anything any other machine could — the idea every CPU since has been a footnote to. At Bletchley Park he turned that theory on the Enigma, and in 1950 he asked the question we’re still arguing about: not whether machines can think, but how we’d ever agree that they do.
“We can only see a short distance ahead, but we can see plenty there that needs to be done.”
— Computing Machinery and Intelligence, 1950
Turing-complete, Turing test, Turing Award, Turing machine — four different things, one person. The bar for naming things after yourself has never recovered.
CleverThis Phase I is the command center for the agent era: a place to develop, version, deploy, and orchestrate any agent — local or cloud — in hierarchies built for the long, multi-step jobs that flatten single-shot models. A supervisor decomposes the work; workers execute bounded units; actors are the only nodes allowed to touch the outside world. Each is an addressable, versioned unit you can branch, diff, and roll back like code.
The bet is unglamorous on purpose: you cannot align, audit, or improve what you cannot reproduce. So everything that runs here is inspectable from step zero — every prompt, tool call, and state transition captured as a replayable trace. Phase I ships nothing clever about thinking. It ships the substrate that keeps the next four phases legible while it is still safe to read them.
schemaA run is a tree. The supervisor plans and delegates; workers do bounded units of work; actors are the only nodes allowed to touch the world — APIs, files, money. Every edge is logged; every node is versioned.
Named for Alan Turing, scoped for 2024 — 2026. Each workstream ships on its own cadence; none ships without the gates further down this page.
Phase I is not a forecast — it is shipping. v1.0 is in your hands now, and the milestones below are the releases landing over the next few months. Each one unlocks the next, and the last of them cuts the socket that Phase II’s reasoning engine plugs into.
Public, Apache-licensed release of the command center, installable in one command.
Docker, bare-metal, and one-click cloud images — all from one artifact.
Model samples, tool returns, clocks, and seeds written to a content-addressed log.
Step, rewind, and fork any run from any point in its history.
Compare two runs by shape and decisions, not as flat text.
Stop and timeout signals cascade down the whole subtree.
Compute and step budgets flow from parent to child.
The same artifact runs single-process or across a cluster.
Actors request scoped capabilities; supervisors grant or deny.
Block writes, spends, and sends behind an approval hook.
Isolate and audit everything that touches the world.
Hash prompts, tools, policies, and model pins into an immutable id.
Diff behavior by intent — tools added, constraints relaxed — not by characters.
dev → staging → prod with a signed, auditable trail.
Every tool call, token, and transition with causal links.
A behavior change is flagged before it can ship.
Shareable, signed, sandboxed capabilities for the community.
Fully offline, no phone-home, reproducible builds.
An independent audit before enterprise GA.
Multi-day jobs that checkpoint and resume without losing state.
The stable, versioned interfaces Phase II’s engine plugs into.
Phase I 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.
A milestone is a promise; a method is how you keep it. Below is the working approach for each Phase I workstream — written the way we would brief a new research engineer on their first day, because this is the part that has to be right before anything clever is allowed near it.
ObjectiveA minimal, total set of primitives that compose into arbitrarily complex agents while staying inspectable at every level.
Property-based tests assert that a randomly generated tree replays identically; chaos tests kill nodes mid-run and assert clean settlement with no partial writes.
Any run, at any depth, reconstructs bit-for-bit from its log, and cancellation never leaves an actor half-finished.
ObjectiveTreat behavior the way we treat source: branchable, diffable, reversible, and signed.
Every release carries a reproducible-build attestation; a nightly job redeploys a random historical artifact and asserts identical behavior.
Any production behavior can be reverted in one command, and any two builds can be proven identical or shown to differ semantically.
ObjectiveOne artifact, three substrates — laptop, your cloud, fully air-gapped — with zero behavioral drift.
A conformance suite runs the identical agent on laptop, cloud, and air-gapped targets and asserts trace-equivalent results.
A new user goes from clone to a deployed agent in under five minutes, on hardware they own, with no account.
ObjectiveMake every run legible as it happens, so nothing the platform does is ever a black box to its operator.
Synthetic incidents are injected and on-call must reconstruct root cause from the trace alone, with no access to the running system.
100% of production runs are reconstructable, and every actor has an enforced budget and an escalation path.
Phase I hands Phase II a system where every run is reproducible, inspectable, and reversible. You cannot measure a moving target you can't re-run — so the substrate had to come first. Now we can turn behavior into signal.
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.
Turing asked when we should grant that a machine thinks. We ask it on purpose, up front: every agent here is reproducible, inspectable, and open. You cannot align what you cannot read — so we make the whole stack readable while it is still safe to.
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.
We cannot prove an arbitrary agent run terminates. Phase I answers with budgets and watchdogs, not proofs — every actor has a step ceiling and a pager, because “it’ll probably finish” is not an operational stance.
Hierarchies multiply failure modes: a worker can succeed while the supervisor’s plan is wrong. Deterministic replay is the bet that you can always reconstruct why, not just what.
Self-hostable and Apache-licensed means anyone can run anything. Signed releases and reproducible builds are the floor; a malicious tool is still a malicious tool. Provenance is a Phase III problem we start paying down now.
while (!halts) { instrument(); } // we can’t prove every run terminates — so we watch every run that doesn’t.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.
Phase I is almost all infrastructure: maximal observability, openness, and oversight; intelligence is barely switched on. The shape fills out left-to-right over the next four phases.
The honest contrast — what the world looks like without Phase I, and what it looks like with it.
One task, decomposed into a tree, executed and logged.
Concrete things Phase I puts within reach — not someday, but as each milestone above lands.
Reconcilers and pipelines that don’t flatten on step 12.
Agents that call your APIs behind human-approval edges.
Run hierarchies on your own hardware, fully offline.
Versioned agents you can diff and roll back like code.
The handful of terms this phase introduces — the words you’ll need to read the rest of the page, and the docs.
Plans and delegates; owns the run.
Executes one bounded unit of work.
The only node allowed to touch the world.
The signed, versioned definition of an agent.
Re-running a run bit-for-bit from its log.
A budget and pager on every actor — the halting problem’s answer.
Straight answers, in the brand’s voice. Tap a question.
The work this phase is built on — read the source, then come build the next line of it.
The universal machine, and the halting problem.
The stored-program architecture everything runs on.
Interleaving thought and tool use in agents.
Build your first hierarchy in under five minutes.
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.
