Terminus is the first self-editing organism built after AI-assisted development removed the ceiling that had stalled every earlier attempt at this idea: all logic used to have to be hand-coded, so nothing ever compounded.

01 · Hypothesis

If a self-editing loop is built at the smallest possible scale — the simplest thing that could plausibly be called biological — the basic mechanism (react to environment, mutate, keep the mutation if it's beneficial, discard it if it isn't) should hold on its own, independent of how capable the underlying model is. Proving the loop works at all, on the smallest possible organism, has to come before attempting anything more cognitively ambitious.

02 · Experiment

Terminus wraps Tessera-1B — deliberately chosen not for capability but because it was small enough to be a clean substrate, and because building on it doubled as a nod of respect to AIIT-Threshold, the first lab to publish a small model and its training data openly. The organism boots from persistent memory (sandbox/memory.sqlite), reads recent lifecycle events, may apply one small JSON-patch mutation per cycle, runs syntax and smoke validation, rolls back to a known-good checkpoint on failure, and — if the mutation succeeds — restarts and inherits the same memory going forward.

The whole loop sits inside one rule the agent cannot touch: it may change anything inside its sandbox, and it may not change the sandbox boundary itself. Everything outside that line — the Dockerfile, the supervisor, the recovery script, the observer, the network rules — is fixed.

This was approached like a single-celled creature evolving, not like an attempt at intelligence: react to the environment, mutate, and if the mutation is beneficial, keep it — that is evolution, at least at the scale this was built to test. You need to learn to walk before you can run.

03 · Result

The question this was built to answer — will this even work, at all — got answered, and that was largely the end of it. Tessera-1B is not a very capable model, and it was never meant to be; this was an experiment in whether the mimicry idea held up, not a push for capability. Once that question was settled, attention moved straight to the next iteration. Tessera itself has barely been run beyond debugging since.

Terminus wasn't even the first attempt at this — Nova came before it. It went public mostly to shine a light on the Tessera project and return the respect of being open about training data, not because it was the most significant work in the tree. Left to the usual pattern, it would likely never have seen daylight at all — which is the fate of most of these experiments.

04 · What I Currently Believe

Self-evolving code was never a wrong idea — it was blocked by a real technical ceiling (every rule had to be hand-coded) for roughly the length of a career, and that ceiling is now gone. Terminus confirms the basic loop holds at the smallest scale it could be tested at: a validated mutate-and-keep cycle, bounded by a hard rule the agent can't override, run on a genuinely simple substrate. That's a precondition, not a result in itself — it says the mechanism works, not that anything interesting has evolved yet.

Most of these projects exist to answer "can I, and what happens when I do" — curiosity rather than a deliverable — and that's treated as a legitimate reason to build something, not a lesser one, even though it usually means the work stays private by default.

05 · What Would Falsify It

(Proposed, not yet confirmed.) If the validated mutation loop, run over many cycles, never actually accumulates a change worth keeping — every mutation that passes syntax and smoke validation turns out to be neutral or is eventually rolled back, with nothing compounding across restarts — that would falsify the claim that this is evolution at small scale rather than noise that happens to pass a test suite. It would mean the loop is a validated-change mechanism, not a selection mechanism, and the two are not the same thing.

Editor's note: built from a follow-up interview about Terminus, cross-referenced against its README and public-release checklist. Section 05 is a proposed falsification test, not something stated directly — flagged for confirmation, the same way log-005's was before you corrected it.

Every attempt at it back then met the same fate. All logic had to be hard-coded, by hand, rule by rule — there was no way for the system to generate its own new logic, only to run the logic it had already been given. So nothing ever compounded. No snowball effect. Each experiment was a dead end for the same underlying reason, regardless of how it was designed.

AI-assisted development is what finally removed that ceiling. A solo developer can now cover enough ground, quickly enough, for the old idea to be worth trying again — not because the idea changed, but because the thing that was blocking it did.

Where this shows up

This isn't the origin story of any one project — it's the reason several exist:

• Terminus is the first attempt built after the ceiling lifted: the smallest possible test of a validated self-editing loop, deliberately scoped down to "does the mechanism even work."
• Omega Observer → Omega ACA is the same underlying instinct — systems that change their own structure rather than just executing fixed logic — applied to memory and cognition instead of code.
• Why an LLM Doesn't Have a Will is arguably the same question again, one level up: not "can the code rewrite itself" but "can the system generate its own reasons to act" — a system that isn't just running rules it was given.

A twenty-plus-year-old idea, tried repeatedly and abandoned repeatedly for one consistent, structural reason, isn't the same thing as an idea that was wrong. It just needed a precondition that hadn't arrived yet.