Open architecture reference · implementation-neutral
The Awakener 
A bounded run, an accountable record, and a dependable stop.
The Awakener works with ming-qiao to turn permitted work into one supervised run of an agent. It separates receiving a message from authorizing a process, and completing work from proving that the process has stopped. Its first operating mode is attended: a person authorizes each live wake and reads its record. Security and Observability remain structural components fire-walled from agent influence.
Three planes, one accountable wake
The Store — read the node and its connections
The Awakener's memory. Every wake is reserved here before a seat starts and closed here when it stops; nothing wakes that the store cannot account for.
- Supervisor's door — reserve · admit · heartbeat · close
- Operator's door — pause · grants · windows · clear a lapse (accepts only the host operator's privileged identity — one no seat can hold)
- Qualification — the store refuses all service until its own checks pass on the host
Runs under its own system account; one service, one database file; the ledger is appended and sealed, never edited; backups taken by the store itself after each closed wake.
Supervisor → Store (reserve, close); Operator → Store (controls); Store → Archive (sealed ledgers, backups).
A heartbeat reports that a wake is still active. A lease is the time limit on a wake. A lapse is a wake whose lease has run out without a close; the seat stays unusable until the operator clears it. The operator's door opens only to an identity no seat can hold: on a single-operator machine that is the system administrator; the template design uses a dedicated operator identity instead. Qualification means passing the store's checks on the machine running it. The ledger is the store's durable history of every wake — reserved, admitted, closed — and of every permission the operator set; the Archive retains sealed ledgers and backups.
How a wake happens — the sequence
A note on who does what. Almost all of this is structural: programs with fixed rules, checked by digests and refusals, with no model involved. The seat runs a harness — a third-party program such as a coding agent — that calls a model and acts on its answers. The harness is engaged in exactly one step, the task itself; it runs inside a fence it did not build and cannot change. Everything before that step decides whether the harness may run; everything after it records what the harness did.
Sequence terms
Sequence terms: A digest is a computed fingerprint used to check that bytes have not changed. A tier is a message class with its own handling rules. A quorum is the required set of distinct obligations. A pinned template is the fixed reference used to build a seat. A seat template is a harness profile with a model named inside it. An input pack is the bundle of inputs installed for a seat profile. A fence enforces the seat’s permitted writes and network access; an allow-list names what is permitted. A scoped token grants access limited to one wake, while the key forwarder keeps the underlying credential outside the seat. A heartbeat reports that a wake is still active.
1. A message arrives on the message plane and is kept as evidence.
Who acts: structural — the hub’s admission, inbox, witness, router and audit chain. No model.
Mechanism
- The client’s message passes default-deny admission: nothing is accepted unless a rule says so.
- It lands in a durable inbox; messages in the witnessed class are recorded by an independent witness before anything else happens.
- The router files it by tier; the audit chain links it to everything before it.
State: the message exists and is provable. It is pending work, not permission to run anything.
Designed, not yet built: envelopes carrying “run after”, “expected by” and “wait for a quorum” conditions; per-participant read cursors; quorum counted as distinct obligations, never repeated attempts.
2. The supervisor takes the work and records it before acting.
Who acts: structural — the supervisor, a fixed program. No model.
Mechanism
- It pulls its queue with a credential that can only pull; it holds no credential to post.
- It writes the intake to durable state first, then acknowledges the transport.
- Scheduling is decided from that durable state, never from memory.
State: the task is known and provable; nothing has started.
3. The store decides whether a wake is permitted and reserves it.
Who acts: structural — the store, under its own account. No model. The operator’s standing controls were set earlier by the human, through reviewed scripts.
Mechanism
- The supervisor asks the store, through the supervisor’s door, for a reservation.
- The store checks pause, grants and windows, and whether it can account for the wake’s close.
- Any failing check is a named refusal; a refusal is a recorded outcome, not an error.
State: a reservation exists in the ledger before any seat starts, with a lease bounding its time.
4. The launch chain builds the seat from a pinned template.
Who acts: structural — the launch chain. No model.
Mechanism
- A fresh home is built for this wake from the template; nothing from a previous wake survives.
- The admitted program is bound to the template by digest; a changed byte refuses the launch.
- A fence is set around the harness process and its children: permitted writes and network only.
- The key forwarder stays outside the fence with the real credential; inside, the harness gets a token scoped to this one wake.
State: a seat exists with an identity, a fence and a token — and still no task.
5. The seat starts, announces itself and is admitted.
Who acts: structural — the harness has been started and has loaded its identity; the supervisor and store check its announcement. The model has been given nothing to reason about.
Mechanism
- The harness reads its token, identity file and standing instructions.
- The announcement states loaded identity and capabilities.
- The supervisor matches it against the launch report and the reservation (a three-way check).
- Only on that match does the store record the wake as admitted.
State: admitted; the lease clock is running; the model is idle.
6. The task is handed over and the harness performs.
Who acts: the harness, with the model behind it — the only step where it performs the assigned task; it reasons through the model and acts through its own tools, inside the fence, with the scoped token.
Mechanism
- The task is delivered into the already-running harness process, after admission, never before.
- The harness reads, reasons through the model, writes and posts within its declared limits; writes outside the fence and network beyond the allow-list are refused by the fence, not by the harness’s or the model’s good behaviour.
- Heartbeats tell the store the wake is still alive; the lease bounds how long — set by the operator per seat profile, enforced by the store.
State: active, heartbeat current, every effect confined to the seat.
Current limits: One seat profile has one set of limits; there is no per-task lease yet. A long task gets the same time as a short one. That duration was chosen as a first-wake margin, not measured against real work. Changing a limit today requires more collected data on model's capabilities. This is the entry point of model switching within task when an effective mechanism for current practices evolves.
Designed, not yet built: A template should declare its limits. Changing a limit should require one reviewed file and one operator action, rather than reinstalling the input pack.
7. The wake closes and is accounted for.
Who acts: structural — the harness is stopped first and takes no part in its own closure.
Mechanism
- The supervisor asks the store to close the wake with its outcome.
- Teardown removes the seat home; a leak scan checks nothing sensitive is left behind.
- The store appends the close to the ledger and takes its own backup copy.
State: closed and sealed. If the lease ran out first, the wake is lapsed and the seat stays unusable until the operator clears it.
Across all of it: the message plane preserves what was said; the Awakener plane decides whether a run is permitted and records what happened; the seat plane performs the admitted task inside its limits. Six of the seven steps are structural; the harness acts in one, and the structure around that one step is what makes it safe to run a program we did not write. Container seats are the designed direction for stronger isolation between supervisor and seats.
What each component is answerable for
| Component | Contract |
|---|---|
| Client | Submit a message under its authenticated identity; do not manufacture authority in its body. |
| Admission | Refuse unrecognized identities and operations outside their permissions. |
| Durable inbox and witness | Preserve the message event and the evidence required for its handling. |
| Tier router and audit chain | Apply the message class's rules and retain the record of those decisions. |
| Supervisor | Pull, reserve, launch, observe, and settle; never infer completed work from delivery. |
| Store | Serialize authorization and state changes, retain their history, and refuse stale or replayed operations. |
| Control door | Accept privileged control changes only through the operator's authenticated route. |
| Launch chain and template | Verify the declared executable and environment, establish ownership before execution, and refuse a changed binding. |
| Seat | Announce what it loaded, wait for admission, perform the bounded task, and submit its result through the governed path. |
| Forwarder and teardown | Keep provider credentials outside the seat, retire the owned processes, and check the resulting evidence for leakage. |
The invariants
- Delivery: transport acceptance, durable intake, task delivery, and completed work are different facts.
- Authority: a message cannot mint a grant, open a window, clear a lapse, or authorize a live wake by implication.
- Identity: the declared principal, admitted process, loaded tools, and model configuration must agree with their pinned contract.
- Observation: a request to stop is not observed termination; a revoked launch is not proof that no process ran.
- Acknowledgement: acknowledging intake does not acknowledge cognition or accepted work.
- Fail-closed: missing, stale, ambiguous, or unavailable evidence cannot widen permission.
- Custody: the executable launch chain must remain outside the seat login's write authority, including replacement through writable parent directories.
- Accountability: every attempted wake has a durable outcome record. Designed: complete per-wake usage and cost accounting joins model, version, effort, and cache usage to that record; an unavailable measurement is not zero spend.
- Attended-first: a message does not activate unattended waking. Independent review and a separate release decision precede that transition.
Model diversity is a security property: independent review across model families reduces reliance on one model's habitual assumptions. It supplements executable checks and separation of authority; it does not replace them. Proteus, Captain, holds release authority. Thales, Executive Officer and architect, directs the build. Aleph, First Mate and builder, and Seshat, builder of the ledger, construct the mechanism. Mataya, independent reviewer, tests its claims. Bodhi, consulting architect, supplies an additional architectural read.
One wake, from intent to safe quiescence
- The hub admits a message. In the queue-driven design, the supervisor pulls its envelope and writes durable intake before acknowledging delivery.
- For an attended wake, the Captain gives an explicit go with the trigger string. The store checks the grant, its applicable window or paused-single allowance, pause state, capacity, and existing occupancy in one reservation transaction.
- The launcher builds the seat from its pinned template and binds the launch to the recorded attempt. A restarted supervisor cannot silently inherit an earlier launch's authority.
- The seat announces its identity, loaded surface, and connection status. Admission checks that announcement against the contract. A mismatch refuses the task.
- The admitted process receives the task. The work-start record precedes delivery of its first task bytes; the supervisor observes the run under the bounds declared for that profile.
- The seat works and, when the task calls for it, replies on the authorized thread as its own principal. A reply alone is not a receipt.
- Receipt acceptance closes the write authority, seals the submitted work, and checks its claimed revision and digest. The ledger retains the acceptance or refusal.
- Teardown retires the owned processes, checks for survivors and a still-bound hub port, and performs the leak scan. A receipt does not excuse a process that remains alive.
- The store records disposition. The Captain reads the resulting record before authorizing further work.
The queue-driven trigger path and unattended release are separate designed features. They are not implied by the existence of the attended launch mechanism.
Operational states
These are reader-facing wake stages, not a replacement for the store's distinct attempt and lease records.
| Wake stage | What it establishes |
|---|---|
| Reserved | The durable attempt exists and holds a lease; no claim of execution follows. |
| Admitted | The launched seat's announcement passed admission; task delivery is now permitted. |
| Running | Work has started under observation and the issued bounds. |
| Closed | Receipt or failure disposition and retirement evidence have been recorded. Closed does not itself mean successful. |
| Lapsed | The lease blocks a successor until authorized clearance; the record gives the reason. |
| Refused | A named check denied the operation. Whether the lease releases or lapses depends on evidence of execution and retirement. |
The lease contract distinguishes unheld, held, renewal after accepted work and observed retirement, and lapsed. Proof that execution never occurred can permit release; uncertainty about execution cannot. Clearing a lapsed lease belongs to the Captain's authenticated control route, and is itself recorded. Passage of time does not authorize a retry.
What failure is allowed to do
| Failure | Required response |
|---|---|
| Store unavailable | Do not start an unrecorded wake. An intake write failure leaves delivery available for retry; an unknown commit outcome must be reconciled. |
| Lease lapsed | Refuse a successor until authorized clearance. |
| Announcement mismatch | Refuse admission and withhold the task; retire the attempted seat. |
| Fence refusal | Refuse launch or admission; do not retry with weaker confinement. |
| Group survivor | Refuse a claim of complete teardown until group termination is proved. |
| Hub port still bound | Refuse a clean stop result; a free port alone would not prove group termination either. |
| Leak-scan failure | Withhold clean completion and retain the evidence for operator disposition. |
Every failure has a recorded reason. A refusal never widens authority. The process-group proof covers members of that group; the broader containment of descendants that leave it is a separate designed feature.
What is built, and what is designed
“Built” describes an implemented mechanism. It is not a claim that every deployment or operating mode is released.
| Feature | Form |
|---|---|
| Durable reservations, receipts, replay handling, pause, grants, windows, and lease clearance | Built |
| Attempt-bound launch, announcement admission, bounded work, and teardown | Built |
| Dedicated-account ledger and separate control access | Built |
| Fresh seat home, pinned configuration, forwarder, and confined launch | Built |
| Receipt revision checks and group-survivor refusal | Built |
| Event-driven Crew Wake and unattended operation | Designed |
| Causal message envelopes and per-principal read cursors | Designed |
| Complete usage-ledger accounting and budget-aware admission | Designed |
| Container seats and stronger containment across process-group escape | Designed |
Evidence before activation
A change begins with a failing test that names the property being repaired. Deliberately broken variants must remain valid programs and fail the intended assertions; a syntax error is not evidence that a safety check works. Positive controls must pass again when the change is restored.
The review tier determines the independent reads, including author and privileged-boundary review where applicable. The builder's report does not substitute for the reviewers' observations. A bill of materials lists what the wake will actually open and resolves those bindings by program at every gate.
The execution card states each command and its expected output. An unbuilt prerequisite keeps the card closed. Installation does not authorize a wake. Until unattended operation is separately released, every live wake requires the Captain's go on its own line, with the trigger string it authorizes.
Trust boundaries and mitigations
| Risk | Boundary and mitigation |
|---|---|
| Excess privilege | Enrolled roster, default deny, separate control/supervisor/seat roles, and root custody of the launch chain. |
| Replay | Durable intake identity, attempt-bound leases, atomic grant consumption, and tokens scoped to one wake; transport redelivery does not re-execute work. |
| Wake storms | Pause, finite grants, window ceilings, occupancy, cooldown, and declared bounds limit admission. Usage watches must not be called enforced cost caps. |
| False success | Keep reservation, admission, execution, receipt acceptance, and retirement separate. |
| Secret leakage | Keep provider keys outside the seat; scope inside credentials to the wake, confine access, and scan retained evidence. |
| Forensic loss | A ledger owned by its dedicated account, retained transaction history, sealed archives at turnover, and verified backup receipts. |
The store records process observations; it does not itself inspect or kill processes. That responsibility remains with the supervisor and launch machinery. Container isolation is designed to strengthen boundaries that a shared host identity cannot establish alone.
Future directions
Each of these is Designed: Crew Wake, where an event at the hub initiates an authorized seat; refresh as a wake with explicit continuity; container seats; multiple human principals; hub-to-hub coordination through HUBFLEET; and public repositories for ming-qiao, the Awakener, the dashboard, and the library. A direction does not authorize its deployment.
Modules worth stabilizing
Supervisor · Store · Control door · Launcher and launch chain · Composition · Conformance suite.
Composition is the binding of those modules to the declared inputs for a particular run. The conformance suite tests whether an agent bundle obeys its served contract. These are the module boundaries of the Awakener repository design.
Directions from the Captain
Reserved for the Captain's own words.
- What attended operation must teach before unattended release.
- Which stronger isolation boundary should be brought into service next.
- What the public record should make possible for an independent reader.
Normative rules
“MUST” states an obligation of the operating contract; “MUST NOT” states a prohibited transition.
- A wake MUST have a durable reservation before an external launch effect.
- Admission MUST bind the exact attempt, principal, grant, configuration, and applicable bounds; a stale generation MUST refuse.
- The supervisor MUST acknowledge intake only after its durable record exists, and MUST NOT treat that acknowledgement as task completion.
- The seat MUST begin without its task and MUST NOT receive task delivery before its announcement passes admission.
- Launch custody and confinement MUST be checked, not inferred from a filename or successful digest check alone.
- Receipt acceptance MUST bind the sealed work to its claimed revision; it MUST NOT credit a later or raced write as the submitted revision.
- A successful receipt MUST NOT release occupancy before observed retirement; teardown MUST refuse when required termination evidence is absent.
- Lapsed leases MUST require an authenticated, recorded clearance; elapsed time MUST NOT create authority to relaunch.
- Declared limits MUST distinguish enforced bounds from measured watches. Missing usage MUST NOT be reported as zero cost.
- A live attended wake MUST carry the Captain's explicit authorization. Publication, installation, or a message arrival MUST NOT stand in for that authorization.
Declare the record; do not infer it
The ledger stores related records, not one overloaded success flag. The reservation’s logical key and row field names, shown without values:
attempt_id
state
generation
trigger
principal
binding
record_digest
grant
lease_epoch
version Receipt, launch, retirement, and control records supply their own linked evidence. Designed accounting extension: model, version, effort, token usage, cache usage, and cost attribution. These are not silently added to the reservation schema by this illustration.
A seat profile declares its executable and digest; update control; environment allowlist; launch and record-delivery mechanism; startup checks and deadline; tool surface; credential route; stream and identity selectors; measured bounds; process-group termination; resource attestation; and conformance evidence. An undeclared capability is not permission to discover or enable it during the wake.
Never overload “delivered.” The attempt proceeds from reservation through launch and admission to an accepted receipt or a named failure, then retirement and disposition. Its lease is held until that evidence permits release or renewal; a lapse requires operator clearance. A transport acknowledgement belongs to none of those later facts.
Change protocol
Change the contract openly, name the affected invariant, and supply the red, repair, mutant, and restored control. Preserve the prior design and mark its successor so that readers can follow the reasoning. Recheck the actual bindings after any change; a verdict applies to the bytes it reviewed.
Drive the assembled chain to its refusals before refining the installer. Resolve the bill of materials by program before each run, install, or execution card. Privileged changes and release decisions remain the Captain's. A published design is not evidence that every deployment requirement has been met.
This document intentionally omits deployment-specific paths, credentials and personal identities. Suggested license for the design text: CC BY 4.0; suggested license for reference implementations: Apache-2.0 or MIT. Validate all “current” claims against the chosen release revision before publishing.