Lifecycle

Everything that comes into being in an AIBOS sphere is born as a thread, and every thread that matures follows the same defined path from there. This page covers that path: how a thread becomes a project, the six stages a graduated project moves through, and the two mechanisms — experiments and archives — that keep the path from becoming a bottleneck.

From thread to project

Work starts as a Trellis thread — a line of events that can only be added to, never rewritten, and that outlives any single session or agent. Full detail in Trellis threads. A thread doesn't need to graduate to be useful; plenty of threads stay exploratory forever, and that's a legitimate outcome. When a thread has matured enough to warrant it, it graduates — a milestone marked permanently in its history, the same idea as a version tag that can never later be moved or erased. Graduation gives the thread a new status without rewriting or discarding anything about its past: same ID, same full log, new phase.

From the moment it graduates, a thread inherits a defined project lifecycle:

explore → define → build → awaiting-go → running → archived

The six stages

Explore. Open-ended investigation. The point of this stage is that it can end in a dead end without cost — nothing here is committed to becoming real yet.

Define. The work takes shape: what it actually is, and what it's going to become. This is also where reversible experimentation happens, covered below.

Build. The actual thing gets constructed — a skill, or a whole piece of the business.

Awaiting-go. The gate. What's been built sits here until a human explicitly signs off on it going live. This is the one stage in the whole lifecycle where the system deliberately stops and waits rather than moving forward on its own — the one decision that never recedes to an agent, no matter how much trust it's earned elsewhere.

Running. The thing is live and operating. From here, further changes happen through the same propose-it-in-isolation-then-merge-it-in discipline that runs the rest of the company (see Company as Code), rather than through ad hoc edits.

Archived. Retirement, and a legitimate outcome in its own right, not a failure state. Nothing about how something got archived is hidden — see below.

Experiments run alongside, not through the gate

Trying something out gets a first-class, reversible existence of its own, separate from the main build path. An experiment marked EXPERIMENTAL never needs to pass through the awaiting-go gate, because reversibility removes the exact risk that gate exists to catch: nothing irreversible reaching production without a human's sign-off, and a contained experiment carries no such risk by construction. Something that proves itself graduates into the regular build path like anything else; something that doesn't gets retired the same way anything else is — with a record, never silently.

Archiving is never silent

Retiring a thread or a project follows the same guarantee that governs everything else in the standard: it's archived with a marker and a pointer to wherever the work landed, never deleted without a trace. The reasoning behind this matters — the guarantee of not losing anything is what makes people willing to let go and explore widely in the first place. If archiving something felt like losing it, people would hold onto dead work rather than clear it out; the marker is what makes clearing it costless.

Where this connects

The lifecycle described here is the same one /initiativ drives mechanically — the skill that mints an initiative, gives it a home, and walks it through these six stages. See Skills reference for how that's invoked, and The operating model for the principles behind why work starts as a thread, and why nothing here is ever lost for good.