Everything between activity and autonomy is engineered.

Everything downstream is built from what the system has actually seen, so the first loop watches operating reality in the places it already lives: the ERP and CRM, email and messages, documents and spreadsheets, agreed recordings and speech, the browser and desktop surfaces where the work is actually performed, and the outcomes that arrive later from the outside world.

Everything captured is immediately attributed: tied to the people, customers, orders, relationships, decisions, and moments it belongs to, with its source, time, and correction history preserved. Attribution is what turns a pile of exports into evidence.

Evidence then updates a time-aware model of the company: what is true now, what was true then, and, separately, what was known then. That distinction matters later, because a decision can only be judged fairly against the information that existed when it was made.

The owner's value lives in the call, made where the procedure runs out. So the second loop rebuilds the company's consequential decisions as episodes: what the situation was, what information was actually available, what the alternatives were, what was decided, what it cost or earned, and what was corrected afterward.

Around those episodes, the system recovers the judgment that produced them. Some of it shows up in behavior across many similar cases. Some emerges by comparison: why this customer got the concession that one did not. Some has to be asked for, and Eumen carries that question to the owner against the specific trace that raised it, then carries the explanation back.

An owner's explanation enters as attributed evidence. It gets tested against the record like any other claim, because people are often sincere and wrong about how they actually decide.

Making a decision takes more than understanding one. The third loop compiles episodes and recovered judgment into working parts: memory that keeps current facts current, policies that hold explicit boundaries, skills that execute multi-step procedures with verification built in, adapted models where generalization is genuinely needed, and evaluations that define what passing means.

Different learning lands in different places on purpose. A customer commitment belongs in memory, not in model weights. A prohibition belongs in policy, where it can be read and audited. A repeated procedure belongs in a skill with typed inputs and a recovery path. The table below makes the destinations exact.

Every compiled capability is evaluated against cases withheld from its construction. Passing evaluation still does not put it to work: release is a separate decision, and the authority to create real-world effects is a third. A capability that fails is held back for more evidence. One that degrades after release is narrowed, repaired, or revoked.

At runtime the successor behaves like a careful operator. It perceives current conditions, retrieves the context that matters, plans, decides, and acts through authorized tools inside an explicit scope. Where a rule settles a case, a deterministic program runs it; learned judgment is reserved for the cases that need it.

Then it checks its own work. Software reports success cheaply, so a separate read-only observer inspects the target system to establish what actually changed. Confirmed, mismatched, or ambiguous: each result has a defined path, and recovery runs before retry. When the situation is uncertain, the system abstains, asks, or escalates instead of guessing.

The loop closes here. Verified effects and later business outcomes travel back to the decisions that produced them, updating memory, policies, skills, evaluations, and authority. Authority expands only where performance and recovery have been demonstrated under increasingly real conditions, and it can narrow, expire, or be revoked. How that expansion is staged inside an engagement is the process page; what it must prove is the proof page.