Autonomous, self-improving AI is often described as though improvement were unconditional. We built an autonomous loop that chains our system's existing layers — memory, fenced reasoning, planning, tool use, reflection, and a learning controller — into a continuous goal-pursuing cycle, and measured whether each cycle actually improves on the last across three deliberately different task types. The loop converged to a correct solution in one cycle on a solvable tool task, improved from 0.08 to 0.97 over five cycles on a task with exploitable feedback, and failed to improve at all on a task with no learnable signal. The finding is the contrast: autonomous self-improvement is real but bounded by whether the task exposes a gradient the loop can exploit. We report the plateau and the failure alongside the success.
A common architecture diagram places 'continuous self-improvement' at the base of an autonomous agent, implying the system reliably gets better over time. In practice, no system improves unconditionally; improvement depends on the task providing feedback the agent can use. Rather than claim general self-improvement, we built the loop and measured its real behaviour, including where it stops improving. An evaluation that cannot fail cannot distinguish genuine autonomy from wishful description.
Each cycle runs: recall from memory; produce an action (invoke a matching tool, or compose from memory and the previous cycle's result); evaluate the action against the task's objective judge; reflect to estimate confidence and detect failure; and let a learning controller decide whether the attempt enters memory for future cycles. State carries forward, so a later cycle can build on what an earlier one established. The reasoning step runs behind the verification fence (TR-08), so no cycle proceeds on a fabricated intermediate claim.
We ran the loop on three task types, each with an objective scorer returning a value in [0,1]: (A) a solvable arithmetic task a tool can compute exactly; (B) a refinement task with a hidden target and warmer/colder feedback the loop can exploit; (C) an adversarial task whose scorer is pure noise, offering no signal. Each task ran up to eight cycles.
| Task | Score trajectory | Outcome |
|---|---|---|
| A — solvable tool | 1.00 | converged, 1 cycle |
| B — refinement | 0.08 → 0.97 | improved, 5 cycles |
| C — adversarial | ~chance | failed to improve |
On Task A the loop reached the correct answer immediately and stopped. On Task B it improved monotonically across cycles by feeding each result into the next attempt, climbing from near-zero to 0.97 — genuine autonomous refinement. On Task C, where the scorer carried no exploitable structure, the loop's scores fluctuated around chance and never improved; the loop correctly reported this as a plateau rather than manufacturing progress.
Self-improvement in the loop is entirely a function of exploitable feedback. Where the task exposes a gradient — a correct answer to reach, or a signal indicating warmer or colder — the loop climbs it. Where it does not, no amount of iteration helps, and the honest system says so. This bounds the 'continuous self-improvement' claim precisely: the mechanism is real and demonstrable, but it is not a general capability that improves on arbitrary tasks. It improves on tasks that are, in a specific sense, improvable.
We built the autonomous loop the architecture calls for and measured its self-improvement honestly. It converges, it refines, and it plateaus — each on the appropriate task. The contribution is not a claim of open-ended self-improvement but a demonstration, with measurements, of exactly where autonomous iteration helps and where it cannot. For a system whose value proposition is trust, reporting the ceiling is the point.