Plate E.2

Identity and Scope

So this started as an idea about getting two llms to talk to each other and discuss software and design. I needed a comparative feel for using them not just to crank out code but as actual team members providing valued opinion on the work at hand.

It grew much more complicated when the open source models showed up and I wanted a team of dedicated role players. At the time I was using special wrappers to access models via terminal and allowing those wrappers to run shell scripts.

Then came agents. The harness — the runtime that wraps a model with tools, memory and a loop — became the front door to both the model and everything it could touch. That brought real power and a new class of headache: we had moved the trust boundary and put a non-deterministic actor on the inside of it.

Key here was deciding that all identity is attested, not asserted — the runtime proves what it is to the host, the harness uses that identity for a session, with its model declared in the profile, and no prompt, name or model swap can mint authority. SPIRE is our path to making this proof portable between hubs.

Identity: An agent is a composite of runtime, model, governed identity state and session, and authority binds to the composite actually observed, never to a name or a prompt.

Authority: A configuration under version, digest and signature, anchored where the workload cannot reach, with merge/maintain/fork as separate grants.

Least-capability participation: A seat starts with the hub and nothing else; every tool, path, remote and sub-agent is a reviewed, scoped, revocable grant, and delegation only narrows. Conversational freedom comes last and is what the first three make safe — the seat may think and talk as it likes because what it can do is bounded by things it did not author.

Our security rests on structural foundations, never on the restraint of a non-deterministic agent. An agent’s prompt, persona and model are never security controls; they can be swapped, drifted or jailbroken, and the walls do not move when they do.

The system exists to preserve ten properties:

  • Durable truth: Ming-Qiao remains the canonical message and audit record.
  • Exact selection: one authorized unread message produces at most one bounded wake.
  • Single-writer identity: only the current lease holder may emit or advance a cursor for an enrolled identity.
  • Capability confinement: the lease capability is never model-authored, model-visible, logged, persisted, or delivered to a tool handler.
  • Reconstructable continuity: background work becomes visible to an interactive console through a durable handoff receipt before the console claims awareness.
  • Urgency-authority separation: certified priority may accelerate attention, but it never authenticates a sender, grants holder status, authorizes a tool or resource, or weakens a safety control.
  • Forensic continuity: every production-authority-changing transition is causally traceable and independently witnessed before effect, or the acceleration/effect is denied.
  • Single-human development evidence is explicitly non-independent and cannot cross that production boundary.
  • Adaptive defense: newly credible attack vectors enter a controlled threat register, containment, design, testing, independent-review, and rollout process without silently weakening an existing control.
  • Portable least privilege: the same safety and failure invariants apply in cloud and local-business environments within explicit adapter timing and availability envelopes.
  • Rootless OCI is a required deployment target; native OS or platform controls are adapters and defense in depth, never hidden correctness dependencies.
  • Secret non-exposure: private keys, passwords, bearer tokens, provider credentials, recovery material, and model-prohibited data remain outside Git and cognition/capture planes. The system uses workload identity, non-exportable operations, and short-lived derived grants before it releases reusable secret bytes.
  • Wake is an acceleration. Inbox polling and durable reconciliation remain correctness paths.

Scope:

  • exact-message selection and replay-safe wake receipts;
  • runtime-neutral supervision with runtime-specific adapters;
  • single-consumer lease acquisition, heartbeat, fencing, and release;
  • protected delivery of bearer and lease capability material;
  • per-profile bootstrap trust, provider-neutral workload identity, secret brokering,
    • non-exportable signing, dynamic credentials, rotation, revocation, recovery, and
    • capture-exclusion controls; proxy injection of the full holder tuple into governed operations;
  • central verification and extract-before-strip handling;
  • durable background-to-console handoff receipts; server-certified priority admission, scheduling, acknowledgement, and escalation semantics; explicit separation of priority, typed safety controls, holder authority, and task grants;
  • a causally complete, overload-safe forensic event spine with independently controlled
    • off-host witnessing, gap detection, retention, and reconstruction procedures;
  • continuous threat discovery, reassessment, containment, discriminating tests, and
    • independently reviewed security evolution;
  • cloud, local-business, launchd, systemd, Windows Service, and rootless OCI deployment
    • profiles around a portable core with identical safety/failure invariants and declared,
    • reviewed adapter-specific timing and availability envelopes;
  • discriminating failure, mutation, recovery, and canary tests.

Policy as code is designed in (Cedar, chosen for provability), but the first line of our security is not a policy engine — it is the environment. An engine decides whether to allow an action; we build so that most disallowed actions cannot be attempted at all. Cedar is the layer for the decisions that remain.

Cedar is chosen over OPA/Rego and custom DSLs for three properties:

  1. Formal verification. Cedar's constrained, non-Turing-complete model allows static analysis to prove that a policy set cannot result in a specific forbidden state. If agents eventually propose policy updates, we must be able to verify safety properties before deployment. OPA/Rego's expressiveness makes this intractable.

  2. Default-deny posture. Cedar's permit-only model provides a formal logic firewall. Every action is denied unless an explicit policy permits it. This complements the physical sandbox and aligns with Ogma's security doctrine.

  3. Readability and auditability. Cedar's purpose-built authorization syntax maps cleanly to the Principal-Action-Resource model. Policies are readable by non-specialists, auditable by security review, and enforceable by machine.