Think inside your AI world.
The ratified goal: a loop you don’t watch
A goal-based loop runs unwatched: you set a goal, it works turn after turn, and a small separate evaluator model judges “done” after each round so the worker doesn’t grade itself. The ratified goal splits the human gesture in two — ratify the criteria before the run, reconcile the divergences after it — which is how a loop you aren’t watching still keeps you as author.
The goal-based loop (Claude Code’s /goal) is a real advance: a dedicated evaluator, Haiku by default, checks whether the goal is met after each turn, so the model isn’t marking its own homework. The open design question it raises is the honest one — what is the ratification gesture inside a loop the human isn’t watching? The ratified goal answers it by moving the gesture upstream to goal definition and adding a downstream reconciliation. Unl holds the criteria the evaluator also checks against.
How does the goal-based loop work?
Fairly described: you give a goal, the loop runs turn after turn without you in the seat, and it stops when the goal is achieved or a maximum number of turns is reached. Its notable design is the separate evaluator — a small model, Haiku by default — that grades “done” after each turn, so the worker doesn’t judge its own output. That’s a genuine improvement over self-grading.
The evaluator checks one thing: is the goal met? It has no view of the decisions you’d already settled, so a run can meet its goal while quietly crossing a constraint you cared about — and, because you weren’t watching, you meet that divergence only when you read the result.
What is the ratified goal?
It splits the human gesture across the run. Upstream, before the loop goes unwatched, you ratify the success criteria and the settled decisions that must hold — and the evaluator’s check becomes two-part: goal met, and no ratified decision violated. Downstream, the loop returns a reconciliation: here is what I did, here are the points where I made a judgement call, here is where I diverged from decision X.
You then ratify or roll back — cheaply, because the divergences are named rather than buried. That is the answer to the hard question: the ratification gesture inside an unwatched loop is a pre-run gate plus a post-run reconciliation.
Where does the ratification gesture live in a goal-based loop?
In two places: upstream at goal-setting, where you ratify the criteria and the constraints; and downstream at reconciliation, where you confirm the judgement calls or roll them back. The loop still runs without you turn to turn — but it opens against your ratified frame and closes against it, so authorship survives the fact that you weren’t watching.
Ratify the criteria upstream, reconcile the divergences downstream — the meeting thins out; the verdict remains.
Reads through Unl arrive with measured context — in the presence of the decisions you’ve already settled. The reach lane is live: one box, paste anything. If it speaks MCP, Unl can reach it. Readings arrive unprompted, the data beside the criterion; Unl is a courier, not a warehouse, and keeps only your keys and the frame.
Read further
Questions people ask
What is a ratified goal?
A goal-based loop with the human gesture split in two: before the run you ratify the success criteria and the settled decisions that must hold, so the evaluator checks “goal met” and “no ratified decision violated”; after the run the loop returns a reconciliation that flags every divergence for a one-gesture ratify-or-rollback.
How do you keep authority over a loop you're not watching?
By moving the gesture off the live turn. You ratify the criteria upstream and reconcile the flagged divergences downstream — so the loop runs unwatched but opens and closes against the frame you settled, and recovery is a gesture because the divergences are named, not discovered by re-reading everything.
Does the evaluator model see my decisions?
In the ratified-goal form, the check is extended so the evaluator tests the run against the ratified constraints you set, not just the bare goal. Unl holds those decisions; the reach lane is live and open: one box, paste anything, and if it speaks MCP, Unl can reach it.
What this is
Think inside your AI world — you stay in command
Unlimitless (Unl to friends) holds what you've settled, reads what your tools are showing, and catches what's changed out in the world — and hands your AI whatever bears on the work, the moment it's needed, without you asking. The right thing, in front of the model, unprompted, with you in command of the call. So you keep moving toward what you set out to build, on top of everything you've already decided.
It plugs into Claude, Claude Code, ChatGPT and Cursor as an MCP connector. Quick to connect, in a couple of steps.
Unlimitless is open now to invited Alpha. Apply for the Beta waitlist to come in ahead of the full launch:
Alpha is invite-only · free at launch.