We describe an autonomous agent architecture assembled from independently-tested components: a verification fence, tiered and graph-structured memory, a two-tier world model, self-verification, planning, reflection with corrective directives, and a learning controller. The agent runs a continuous cycle — simulate, act, self-verify, evaluate, reflect, learn — carrying state forward. Rather than claim open-ended self-improvement, we measure the loop's behaviour and report where it improves, plateaus, and fails. The system comprises 49 modules with 83 passing tests and scores 89.5% on an internal capability benchmark. Every component that could be faked with a constant or an in-sample metric is instead measured against a baseline; we describe those measurements and their honest limits.
The architecture does not pursue a larger model. It composes small, individually-verified parts behind a verification layer, on the thesis that a trustworthy agent is built from components whose failure modes are known and measured. Each subsystem was added only with a test that distinguishes it working from it appearing to work — a distinction that matters because several natural implementations of these components produce metrics that flatter themselves (a fence scored against its own output, a world model scored on in-sample data, a self-improvement curve assumed monotonic).
| Layer | Component | What it does |
|---|---|---|
| Verification | Fence | rejects claims not grounded in cited memory |
| Verification | Self-verifier | tests an action against memory before trusting it |
| Memory | Tiered | hot to cold with resolution decay + provable forget |
| Memory | Temporal graph | causal (subject,relation,object) edges |
| Memory | Skill hints | per-domain accumulation of what worked |
| World model | Predictive | LLM-as-simulator, trust decays with depth |
| World model | Surrogate | local MLP, used once it beats a mean baseline |
| World model | Two-tier router | surrogate when warm+confident, else cold fallback |
| Control | Planner | decompose, schedule, replan |
| Control | Reflection | diagnose mistake type, emit corrective directive |
| Control | Learning scheduler | decide learn / queue / ignore |
| Control | ZPD curriculum | recommend next task at achievable difficulty |
Each cycle: (1) the two-tier world model predicts the reward of candidate actions; (2) a skill hint for the domain is applied; (3) an action is produced; (4) the self-verifier checks it against memory before it is trusted; (5) an objective evaluator scores it; (6) the real outcome is fed back to the surrogate so it learns, and causal edges are written to the temporal graph; (7) the competence model updates; (8) reflection diagnoses any failure and emits a directive that steers the next cycle; (9) the learning controller decides whether the attempt enters memory. State carries forward across cycles.
Self-improvement is bounded by exploitable feedback (TR-13): the loop converged on a solvable task, improved from 0.08 to 0.97 on a refinable one, and could not improve on a task with no learnable signal — and reported each honestly. The simulation-accuracy figure is computed as one-minus-mean-absolute-error between predicted and actual reward, not hardcoded; a test confirms it varies with the data. The surrogate world model is measured one-step-ahead (predicted before trained on) against a mean-predictor baseline: on a learnable relationship its error fell from 0.50 at ten samples to 0.03 at one hundred and beat the baseline; on features that do not predict the outcome it correctly reported that it does not beat the baseline, and the two-tier router kept using the cold fallback rather than trusting it.
This is not a general intelligence and not a recursively self-improving system. The action generator in the loop is deliberately simple (tool invocation plus result feedback), not a large language model; the language-model layer remains external, behind the fence, by design. The world model's deep rollouts are speculative and labelled as such. The skill 'adapters' are memory-based hint stores, not fine-tuned parameters. The self-verifier and fence catch grounding and contradiction failures, not every possible error. Improvement occurs only where the task exposes a gradient. We state these boundaries because the value of a trust-oriented system lies in knowing them.
The system is a pip-installable package: 49 modules, 83 tests passing, an internal benchmark suite reporting 89.5% overall including a continual-learning score of 70% that we publish rather than hide. Each measurement above is produced by a script in the package (the loop experiment, the surrogate curve, the benchmark suite), and each can be re-run. The components were built incrementally, each with a test that fails if the component only appears to work.
A trustworthy autonomous agent can be assembled from small verified parts behind a verification layer, and its real behaviour — including its ceilings — can be measured rather than asserted. The contribution is the discipline: every component that admits a self-flattering metric is instead scored against a baseline or a held-out signal, and the boundaries of autonomy are reported as findings. Preliminary results, not peer reviewed.