On this page
Draft 2 (r3) · October 2026 · AstralMaris design series · marked IN PROGRESS
Status
In progress. This is draft 2 of a design. It has had one internal review. It is published as an idea: it does not describe a running system, and it will change.
It answers one question: how can a hub check that an agent seat is the seat that was decided, before it listens to that seat?
It is written to be published. It describes mechanisms and their limits, and it leaves out anything that would help someone attack a running system. The last section lists what was left out and why.
Words
Every term the page uses, in the order a reader meets them.
| Word | What it means here |
|---|---|
| Agent | A harness doing work with its own tools, using a model to reason. |
| Harness | The agent program that occupies a seat (a coding agent or console); it calls a model and acts on the answers with its own tools. Seats hold harnesses; harnesses hold models. |
| Seat | A working position built around a harness: its instructions, tool permissions and environment, with a model named in its profile. |
| Hub | The message service a team of agents and people work through. One team, one hub. |
| Sandbox | A sealed place a seat runs in, with only the files and network it was given. A container is one kind. |
| Record | The decided definition of a seat, kept in version control and changed only when a person merges a change. |
| Fingerprint | A short number computed from a file’s exact bytes. Change one byte and the fingerprint changes. |
| Signature | A mark made with a private key. Anyone holding the matching public key can check it; nobody without the private key can make it. |
| Seat pass | The short-lived signed statement this design introduces. It says which seat this is and what it was built from. |
| Session key | A pair of keys made fresh inside the sandbox for one session. The pass names the public half; the private half never leaves the sandbox. |
| Proof of possession | A signature made with the session key over something fresh. It shows the presenter holds the key the pass names, and has not just copied the pass. |
| Local root | A small fixed program inside the sandbox that records every start in a signed chain. |
| Signer | The service outside the sandbox that checks evidence and issues seat passes. |
| Witness | The hub-side service that keeps, for each seat, a counter and the history of every pass issued, so a stale copy or an old state shows up. |
| Door | The point where a seat’s messages enter the hub, and where passes are checked. |
| Guest | An agent whose seat was not built from this hub’s record. |
| Attestation | The general word for proving what a program is by evidence, not by its own say-so. |
The problem
An agent’s identity today is usually a name and a secret token, so whoever holds the token is the agent. That fails in three ways.
- Substitution. The same name and token can sit on different instructions, a different model or wider tool permissions. Nothing at the door notices.
- Copying. A sandbox is a set of files. Copy it with its token and there are two of the same agent. Restore an old copy and an old state speaks with today’s authority.
- Crossing. A message arriving from another hub, or from a guest, claims an origin. The receiver has no way to check the claim.
A sandbox limits what an agent can do. It does not say which agent is inside. As more agents run in sandboxes that someone else operates, the person responsible for the work needs something sturdier than a name before trust can be given.
Principles
Ten rules the design holds to. Each later section can be checked against them.
- The proof is made by someone other than the thing being proved. A seat never vouches for itself.
- No model in the trust path. Every check is a fixed rule over typed fields. No prose is interpreted, by a model or by a person, at the moment of the check.
- Long-lived keys stay outside the sandbox. What can be copied with the sandbox must not be enough to impersonate it.
- A pass is short-lived and bound to a key made for one session. Showing a pass is not enough; the presenter proves it holds that key.
- A change of model, instructions or tools is a change of identity. It needs a new pass.
- Every refusal has a named reason, written down. A check that fires with no findable reason is no longer reliable and is replaced.
- Report first; enforce by decision. Each move from reporting to refusing is a deliberate ruling by the person responsible.
- It proves origin, not behaviour. The limits are printed beside the claims.
- Open standards and open-source parts wherever they are viable.
- Built for a responsible person who is not a security engineer. The door’s answer is yes or no, with the reason in plain words.
The parts
Seven parts do the work, and the two that decide trust, the signer and the door, both sit outside the sandbox.
The drawing, in words. Three zones.
- Decided (kept in version control, changed only by a person) holds the Record and the Build. The Build is built from the Record.
- Sandbox (may run on a host we do not control) holds the Local root and the Seat.
- Hub side (outside the sandbox) holds the Signer, the Witness and the Door.
Arrows, each with its label:
- Build to Sandbox: image and instructions.
- Record to Hub side: expected fingerprints.
- Local root to Seat: start verdict.
- Local root to Signer: evidence.
- Signer to and from Witness: next number.
- Signer to Seat: seat pass.
- Seat to Door: shows its pass.
- Door to Witness: still the latest?
Read it as two columns under a record. The sandbox holds the seat and its local root; everything that decides trust is on the hub side. The seat never holds the main key and never checks itself.
| Part | Where it runs | What it does | What it never does |
|---|---|---|---|
| Record | Version control | Holds the decided definition of every seat | Changes without a person’s merge |
| Build | The build system | Compiles the instructions; fingerprints the image, the instructions and the tool profile | Gives a different output from the same input |
| Seat | Inside the sandbox | Does the work; holds its session key | Holds a long-lived key; vouches for itself |
| Local root | Inside the sandbox | Records each start in a signed chain; gives a start verdict from a fixed table | Interprets anything; talks to the model |
| Signer | Hub side | Compares evidence with the record; builds and signs the pass | Signs something it was handed |
| Witness | Hub side, in a store of its own | Keeps each seat’s counter and the history of every pass: reserved, active, replaced, revoked, closed | Decides what a seat may do; shares a store or an authority with another service |
| Door | In the hub | Checks every pass and the proof that its presenter holds its key; writes the reason for each refusal | Trusts a name alone |
The witness stands alone. It is a service of its own. It does not share a database, an authority or spare capacity with any other ledger on the hub, so that a pause, a full disk or a closure in one cannot stop the other. Tested storage code may be reused; a store is not.
The seat pass
A seat pass is a small signed record with a fixed list of fields. The door reads fields and never reads prose.
| Group | Field | Why it is there |
|---|---|---|
| Format | Format version | Which version of this field list the pass follows. It also fixes the signing method, so a pass cannot choose its own. An unknown version is refused. |
| Who, and for whom | Issuer | Which signer made this pass, and with which of its keys. |
| Subject | The seat’s name, qualified by its hub. | |
| Audience | Which door may accept it. A pass for one hub is worthless at another. | |
| When | Issued, expires | A pass lives for minutes or hours, never days. |
| Pass identifier | A unique label for this one pass. It is not a counter. | |
| Which running instance | Session and sandbox instance | Names one start of one sandbox. A name alone proves nothing; the next field does the work. |
| Session key | The public half of the key made for this session. The presenter must prove it holds the private half. | |
| What it was built from | Image fingerprint | The exact sandbox image. |
| Harness fingerprint | The harness program and its settings. Left out only where the build puts the harness inside the image, so that the image fingerprint already covers it. | |
| Record revision | The exact revision of the decided definition this seat claims to be. | |
| Instruction fingerprint, compiled | The seat’s instructions in their compiled form, before any harness shapes them. | |
| Instruction fingerprint, rendered | The instructions exactly as rendered for this harness. | |
| What is doing the thinking | Model bundle | Developer, serving provider, model, version and effort settings, each from a controlled list. A version the provider does not disclose is written as undisclosed, never guessed. |
| What it may do | Tool permission profile | Which tools, by a named and versioned profile from the record. |
| Communication surfaces | Where it may send and receive, from a fixed list. | |
| How sure | Mode | Partial or full, set by the kind of evidence that was available. |
| Evidence fingerprint | What the signer looked at, kept for later audit. | |
| Constraints | Flags from a fixed list, such as host-not-verified. | |
| Continuity | Lineage | Which local root’s chain this seat continues. |
| Number in line | The witness’s counter for this seat. It only goes up, and a number is never used twice. An out-of-date number is refused. |
Two fingerprints of the instructions are kept apart on purpose. The compiled one shows that the instruction input is the same whichever model the seat runs on. The rendered one shows what was prepared for one harness. Neither shows that two models interpret the same instructions in the same way, or that their harnesses act on the answers in the same way, and neither shows what a provider’s servers actually processed.
A pass is shown many times, not used up. It is good for its whole session. What stops a recorded message being played back is a separate proof on each message: the seat signs each message, or each opening of a channel, with its session key over a value that is never repeated, and the door refuses a repeat. This is a choice in this draft and may change.
Five rules hold for every pass.
- The field list is closed at every level. An unknown field, or a field given twice, is refused, not ignored.
- Free text is never a field. Every value comes from a controlled list or is an identifier of a fixed form.
- A pass is signed over one exact byte form, with size limits and one fingerprint method, all fixed by the format version.
- A pass describes a seat at its start. What a session went on to use or cost is recorded elsewhere.
- A pass never outlives the session it was issued for.
Lifecycle
Eight steps take a seat from a decision to a verified place at the hub. Each step names the refusals it can give.
Decide. A person merges the seat’s definition into the record: instructions, tools, image, model bundle.
Build. The build step compiles the instructions and fingerprints everything. The fingerprints go into the record. The same input always gives the same output.
Start. Inside the sandbox the local root runs first. It compares this start with its signed chain and gives one of four verdicts: bind, degrade, halt or reset. On halt the seat does not start. A reset begins a new chain for the local root; it never resets the witness’s counter and never erases a closed session.
Ask. The sandbox makes a session key. It sends the signer its evidence and the key’s public half, over a channel where each side proves itself. The signer supplies a fresh random value first, so an old request cannot be replayed. The pass does not exist yet, so on this first contact the sandbox proves itself with a starting credential given to it when the seat was enrolled. How that credential is issued and protected is not yet designed.
Admit. The signer compares the evidence with the record. If it matches, the pass is issued in four moves, always in this order.
- Reserve. The witness reserves the seat’s next number against this request’s own identifier and a fingerprint of the pass’s contents.
- Sign. The signer builds the pass itself and signs it.
- Activate. The witness durably records the exact signed pass as active.
- Release. Only then is the pass sent to the seat.
A crash before activation leaves a reservation and no pass; that number is abandoned and never used again. If the pass is lost on its way to the seat, the same request gets the identical pass back. The witness records that a pass was issued. Whether the seat received it is a different fact, and no step claims it.
Refusals: seat not in the record; fingerprint does not match the record; evidence stale; evidence from a source the signer does not trust; fresh value wrong, expired or already used; no proof of the session key; another instance of this seat already active; witness unreachable or its answer out of date; witness unable to write its history.
Present. The seat shows its pass at the door and proves it holds the pass’s key. The door checks the format version, the issuer, the signature, the time range, the audience and the proof; then, with the witness, that this exact pass is still active. Refusals: unknown format; issuer not trusted; forged; a field malformed or given twice; not yet valid or expired; wrong door; no proof of the key; a repeated message; pass not active (closed, revoked or replaced); the record or the permissions have changed since it was issued; witness unreachable.
Renew or change. A pass is renewed before it expires, by the same four moves; on activation the new pass replaces the old in a single step. If a renewal fails, the old pass stays active until its own expiry. That last rule is a choice in this draft. A change of model, instructions or tools ends the pass and sends the seat back to step 4.
End. A session is closed at the witness by a named authority on named evidence: the service that stopped the sandbox, the signer on a change, or a time limit passing with no renewal. A seat’s own word closes nothing, and neither does its silence before the limit. The pass is dead once closed, even if its expiry has not passed. Which services may close a session, and the time limit for a seat that cannot be reached, are still to be set.
In the reporting stage the door writes each refusal down and lets the message through. In the enforcing stage it stops the message.
What is not yet written. Steps 4 to 8 can all be fixed rules, but they are not yet written as rules. “Evidence matches”, “partial or full” and “session ended” each need an exact test, a named source for every value, and a place in one table of allowed moves between states. The refusal reasons above are working labels; the exact check behind each is written first, and the names are fixed after. One rule in particular is open: a yes at the door holds for the message it was given on, and a message checked before a revocation but acted on after it needs a stated answer.
Guests and other hubs
A hub treats its own seats, guests and other hubs by one rule: no pass, no standing, and the pass’s mode decides how much standing. Everything in this section is a proposal.
Guests. A guest was not built from this hub’s record, so the signer cannot compare it with anything decided here. There are two routes.
- Vouched for by its own hub. The guest’s home hub issues its pass. This hub accepts that signer for a short, named list of things, written in this hub’s record.
- Vouched for by nobody. This hub’s signer issues a partial pass on what it can check, such as the image fingerprint and the declared model. The guest gets a guest profile: it may read and propose, and it may not instruct.
Other hubs. Each hub has its own signer, its own witness and its own key.
- A hub’s name is a label for people. Only the key shows which hub it is.
- Hubs learn each other’s public keys from a fleet list signed by the home hub.
- A message that crosses hubs carries the sender’s pass, with the receiving hub named as its audience, and the sender’s proof that it holds the pass’s key.
- An instruction with no valid pass is refused. A crowd of unknown senders can flood a hub; it cannot command one.
- Where two hubs’ agents meet, a name is written with its hub, as in
agent@hub. - A right does not travel. A permission held on one hub means nothing on another unless that hub’s own record grants it.
Hubs that are out of contact. A hub on a ship or in a closed plant may run for days without the home hub.
- Passes are ordered by their number in line, not by the clock, because the clock may be wrong.
- A longer pass life is allowed only by a ruling for that environment.
- On reconnection the two witnesses are reconciled, and the reconciliation is itself a recorded event. It can record that two histories split. It cannot undo an instruction both sides already accepted.
- A hub fails visibly, never silently. Whether it also refuses work while cut off is decided per environment.
Threats
Fourteen threats. For each, the table says what the design does and what it leaves. No row is answered without a limit, and rows 10 to 14 are not answered by this design.
| # | Threat | What answers it | What remains |
|---|---|---|---|
| 1 | A stolen token is used from somewhere else | A token alone is no longer enough. A stolen pass alone is not enough either: its presenter must prove it holds the session key | Theft of the whole live sandbox, key included, is row 5 |
| 2 | The instructions are changed | The rendered fingerprint no longer matches the record; the signer refuses | Only as strong as whoever measured the evidence: a value a seat reports about itself proves nothing (row 10). Changes inside a seat after it starts are the sandbox’s job |
| 3 | The tool permissions are widened | The profile no longer matches the record | The same limit as row 2 |
| 4 | A different model is put under the same seat | The model bundle no longer matches the record | The same limit as row 2. A provider that silently changes the model behind an unchanged name is not seen |
| 5 | The sandbox is copied and both copies run | Partly. The witness allows one active session per seat, so a copy asking for its own pass is refused, and a stale copy’s number is out of date | Two copies holding the same live pass and session key both pass the door. Copies that take turns renewing are not seen. Closed only by keys that cannot be copied out of their hardware, with attestation (stage 4) |
| 6 | An old snapshot is restored | Its number in line is out of date; refused | Unless the witness was rolled back with it: row 14 |
| 7 | A pass is forged | The signature does not verify | Rests on the signer’s key being safe: row 11 |
| 8 | The signer is tricked into signing something else | The signer builds the pass from typed evidence and never signs what it is handed | This narrows the trick; it does not end it. A caller claiming to be another seat, or trusted evidence gone stale, must be refused by rules that are not yet written |
| 9 | The local root’s key is copied along with the sandbox | Partly. The copy signs validly. Caught only where row 5 catches a copy | Keys in hardware stop the copying. Hardware alone does not prove what instructions are running |
| 10 | The host itself is compromised | Not answered. A host that controls everything can forge evidence that looks exactly like honest evidence | Mode partial is set by the kind of evidence available, not by any power to detect the compromise. Hardware or platform attestation is the later stage |
| 11 | The signer is compromised | Not answered in the first stages. Everything it signs is suspect | Key rotation, the signer’s own log at the witness, and hubs cross-checking each other |
| 12 | The witness cannot be reached | A choice, not an answer: refuse, or run flagged and reconcile later | Decided per environment |
| 13 | The agent is misled by something it reads | Not this design. A pass proves origin, not behaviour | The sandbox, tool permissions and review reduce this. They do not close it |
| 14 | The witness is rolled back, compromised or split in two | Not answered yet. A restored witness and a restored seat can agree on an old number. A chained history shows edits; it does not show that the whole history is current | One witness authority per hub; a recovery mark that sets every counter past any restored value; an outside anchor, or a rule to refuse every seat until it is enrolled again |
Stages
The design is reached in five stages, and each move to the next is a ruling by the person responsible, not an upgrade that happens by itself.
| Stage | Name | What is true | What the door does |
|---|---|---|---|
| 0 | Self-reported | Seats publish their own fingerprints; people compare them by hand | Trusts the name and the token |
| 1 | Signed, reported | The signer issues passes; the door checks them | Writes down yes or no; stops nothing |
| 2 | Enforced | The witness is live; stale copies and old states are caught | Refuses a seat with no valid pass |
| 3 | Between hubs | Hubs hold keys and exchange them; guests have profiles | Refuses an instruction from another hub with no valid pass |
| 4 | Rooted in hardware | Keys live in secure hardware; the platform attests the host where it can | Accepts mode full only with hardware evidence |
Stage 0 is where most agent systems are today. In stage 1 the door stops nothing, so it can run beside real work while its refusals are judged. It is not free of risk: it makes work depend on a signer and a door check that were not there before, it adds to the logs, and the evidence it records may itself be sensitive. It gets its own operational review before it runs.
What we build on
Nothing here needs a new kind of cryptography; the design combines established, open pieces.
| Piece | What we take from it |
|---|---|
| SPIFFE and SPIRE (an open standard for workload identity and its open-source implementation) | The separation of duties: one party checks evidence, one signs, one verifies. Also a candidate for certificates between hubs’ services. |
| Ed25519 signatures | Signing passes and the local root’s chain. |
| Hash chains | Each start mark names the fingerprint of the one before it, so a change to an earlier mark breaks every mark after it. That shows an edit. It does not stop someone who can rewrite every later mark as well; the signatures and the witness are what stop that. |
| Signed container images (the Sigstore approach) | An input to the signer: proof of who signed the image. It does not show where or how the image was built. It is evidence, not identity. |
| OIDC federation | Handing a verified seat its cloud credentials. It carries a claim; it does not decide what the claim should say. |
The design descends from three earlier designs of ours: a local identity layer, a compiler that fingerprints an agent’s instructions in two forms, and a signing-service proposal.
Where it stands
This is a design in progress, published as an idea. It does not describe a running system, and it does not say how far any system has been built.
The next revision writes the exact test behind each step and each refusal, the table of allowed moves between a pass’s states, and the recovery of the witness after a restore. Each of those is marked above as not yet designed.
Kept off this page
The design can be published because its safety does not depend on the design being secret. The secrets are the keys, and no key, and nothing that leads to one, is on this page.
Left out on purpose:
- names of machines, accounts and folders
- where any key is kept and who can reach it
- the network layout and software versions of any running system
- the state, open findings and known gaps of any running system
- incident evidence
- internal security documents
- the exact byte format of a pass, until it is built and reviewed. This waits for review; the format being secret protects nothing.
AstralMaris is one operator and a small fleet of AI agents on Apple-silicon hardware. This series records designs the fleet runs, with the measurements that shaped them. Companion papers: Container Seats; HUBFLEET.