AstralMaris design series · In progress

Verified Seats

How a hub checks that a seat is the seat that was decided, before it listens to it

OCT 2026 · Draft 2 · revision 3 · in progress

Proposed trust boundaries

Design in progress

On smaller screens, scroll the drawing horizontally to read every label.

Verified Seats: the record, the sandbox and the hub-side checksThe human-decided Record supplies the Build and the hub’s expected fingerprints. The Build delivers an image and instructions to the sandbox. Inside it, the Start guard (called local root in revision 3) gives the Seat a start verdict. The numbered flow is: 1, evidence leaves the Start guard for the Signer; 2, the Signer reserves a number with the Witness; 3, the Signer signs the pass and the Witness records it active; 4, only then does the Signer release the signed seat pass to the Seat. The Seat presents the pass and proof that it holds its session key to the Door. The pass is short-lived. The Door checks with the Witness on every presentation that the pass is still the latest. These are proposed checks of origin, not proof of behaviour.DecidedChanged only by a person’s mergeSandboxContained runtime; host may be outside our controlHub sideTrust decisions stay outside the sandboxbuild from recordimage + instructionsexpected fingerprintsstart verdict1evidence2reserve3sign ·record active4releasesigned seat passshort-livedpass + key proofstill latest?each presentationRecordHuman-decided seat definitionBuildCompile instructions; fingerprintimage, instructions and tool profileStart guard (local root)Fixed checks before the seat runs;signed start history.SeatAgent, tools and a session key pairSignerCompare evidence; sign the seat passWitnessOwn store: counter and pass historyDoorCheck pass, key proof and current status

The signer and door sit outside the sandbox. The witness keeps its own counter and pass history.

Fingerprints identify exact bytes. A seat pass is a short-lived signed statement; key proof shows the seat holds its session’s private key.

Proposed issue order: reserve a number → sign → record active → release.

Proof of origin, not behaviour. Read the parts and boundaries ↓

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.

WordWhat it means here
AgentA harness doing work with its own tools, using a model to reason.
HarnessThe 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.
SeatA working position built around a harness: its instructions, tool permissions and environment, with a model named in its profile.
HubThe message service a team of agents and people work through. One team, one hub.
SandboxA sealed place a seat runs in, with only the files and network it was given. A container is one kind.
RecordThe decided definition of a seat, kept in version control and changed only when a person merges a change.
FingerprintA short number computed from a file’s exact bytes. Change one byte and the fingerprint changes.
SignatureA mark made with a private key. Anyone holding the matching public key can check it; nobody without the private key can make it.
Seat passThe short-lived signed statement this design introduces. It says which seat this is and what it was built from.
Session keyA 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 possessionA 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 rootA small fixed program inside the sandbox that records every start in a signed chain.
SignerThe service outside the sandbox that checks evidence and issues seat passes.
WitnessThe 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.
DoorThe point where a seat’s messages enter the hub, and where passes are checked.
GuestAn agent whose seat was not built from this hub’s record.
AttestationThe 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.

  1. Substitution. The same name and token can sit on different instructions, a different model or wider tool permissions. Nothing at the door notices.
  2. 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.
  3. 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.

  1. The proof is made by someone other than the thing being proved. A seat never vouches for itself.
  2. 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.
  3. Long-lived keys stay outside the sandbox. What can be copied with the sandbox must not be enough to impersonate it.
  4. 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.
  5. A change of model, instructions or tools is a change of identity. It needs a new pass.
  6. Every refusal has a named reason, written down. A check that fires with no findable reason is no longer reliable and is replaced.
  7. Report first; enforce by decision. Each move from reporting to refusing is a deliberate ruling by the person responsible.
  8. It proves origin, not behaviour. The limits are printed beside the claims.
  9. Open standards and open-source parts wherever they are viable.
  10. 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.

PartWhere it runsWhat it doesWhat it never does
RecordVersion controlHolds the decided definition of every seatChanges without a person’s merge
BuildThe build systemCompiles the instructions; fingerprints the image, the instructions and the tool profileGives a different output from the same input
SeatInside the sandboxDoes the work; holds its session keyHolds a long-lived key; vouches for itself
Local rootInside the sandboxRecords each start in a signed chain; gives a start verdict from a fixed tableInterprets anything; talks to the model
SignerHub sideCompares evidence with the record; builds and signs the passSigns something it was handed
WitnessHub side, in a store of its ownKeeps each seat’s counter and the history of every pass: reserved, active, replaced, revoked, closedDecides what a seat may do; shares a store or an authority with another service
DoorIn the hubChecks every pass and the proof that its presenter holds its key; writes the reason for each refusalTrusts 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.

GroupFieldWhy it is there
FormatFormat versionWhich 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 whomIssuerWhich signer made this pass, and with which of its keys.
SubjectThe seat’s name, qualified by its hub.
AudienceWhich door may accept it. A pass for one hub is worthless at another.
WhenIssued, expiresA pass lives for minutes or hours, never days.
Pass identifierA unique label for this one pass. It is not a counter.
Which running instanceSession and sandbox instanceNames one start of one sandbox. A name alone proves nothing; the next field does the work.
Session keyThe public half of the key made for this session. The presenter must prove it holds the private half.
What it was built fromImage fingerprintThe exact sandbox image.
Harness fingerprintThe 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 revisionThe exact revision of the decided definition this seat claims to be.
Instruction fingerprint, compiledThe seat’s instructions in their compiled form, before any harness shapes them.
Instruction fingerprint, renderedThe instructions exactly as rendered for this harness.
What is doing the thinkingModel bundleDeveloper, 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 doTool permission profileWhich tools, by a named and versioned profile from the record.
Communication surfacesWhere it may send and receive, from a fixed list.
How sureModePartial or full, set by the kind of evidence that was available.
Evidence fingerprintWhat the signer looked at, kept for later audit.
ConstraintsFlags from a fixed list, such as host-not-verified.
ContinuityLineageWhich local root’s chain this seat continues.
Number in lineThe 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.

  1. Decide. A person merges the seat’s definition into the record: instructions, tools, image, model bundle.

  2. Build. The build step compiles the instructions and fingerprints everything. The fingerprints go into the record. The same input always gives the same output.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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.

  8. 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.

#ThreatWhat answers itWhat remains
1A stolen token is used from somewhere elseA token alone is no longer enough. A stolen pass alone is not enough either: its presenter must prove it holds the session keyTheft of the whole live sandbox, key included, is row 5
2The instructions are changedThe rendered fingerprint no longer matches the record; the signer refusesOnly 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
3The tool permissions are widenedThe profile no longer matches the recordThe same limit as row 2
4A different model is put under the same seatThe model bundle no longer matches the recordThe same limit as row 2. A provider that silently changes the model behind an unchanged name is not seen
5The sandbox is copied and both copies runPartly. 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 dateTwo 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)
6An old snapshot is restoredIts number in line is out of date; refusedUnless the witness was rolled back with it: row 14
7A pass is forgedThe signature does not verifyRests on the signer’s key being safe: row 11
8The signer is tricked into signing something elseThe signer builds the pass from typed evidence and never signs what it is handedThis 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
9The local root’s key is copied along with the sandboxPartly. The copy signs validly. Caught only where row 5 catches a copyKeys in hardware stop the copying. Hardware alone does not prove what instructions are running
10The host itself is compromisedNot answered. A host that controls everything can forge evidence that looks exactly like honest evidenceMode 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
11The signer is compromisedNot answered in the first stages. Everything it signs is suspectKey rotation, the signer’s own log at the witness, and hubs cross-checking each other
12The witness cannot be reachedA choice, not an answer: refuse, or run flagged and reconcile laterDecided per environment
13The agent is misled by something it readsNot this design. A pass proves origin, not behaviourThe sandbox, tool permissions and review reduce this. They do not close it
14The witness is rolled back, compromised or split in twoNot 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 currentOne 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.

StageNameWhat is trueWhat the door does
0Self-reportedSeats publish their own fingerprints; people compare them by handTrusts the name and the token
1Signed, reportedThe signer issues passes; the door checks themWrites down yes or no; stops nothing
2EnforcedThe witness is live; stale copies and old states are caughtRefuses a seat with no valid pass
3Between hubsHubs hold keys and exchange them; guests have profilesRefuses an instruction from another hub with no valid pass
4Rooted in hardwareKeys live in secure hardware; the platform attests the host where it canAccepts 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.

PieceWhat 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 signaturesSigning passes and the local root’s chain.
Hash chainsEach 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 federationHanding 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.

Back to the title ↑