Skip to content
UHPUHPDeveloper Guide
Independent developer guide. Not affiliated with HarnessRouter or the official UHP project.

UHP security and trust boundaries

The current normative UHP security model from specification version 2026-10-19. A UHP server runs an agent that executes tools, writes files, may load third-party Harness Plugins, and holds a provider credential on behalf of a caller it has never met — a larger blast radius than a model endpoint. This page collects the protocol's security requirements and the trust responsibilities they imply.

Page reviewed 8 Nov 2026 Source and review policy

Protocol: 2026-10-19Static SSG

What 2026-10-04 adds on the security surface

Section titled “What 2026-10-04 adds on the security surface”

The optional Memories chapter adds eight error codes to the taxonomy, and they separate two failures that used to look identical: memory_not_found (404, no such memory or one the caller holds no privilege on — the two are one answer) and memory_forbidden (403, the caller sees the memory and lacks the privilege the operation needs). The rest are memory_record_not_found, memories_not_attached, memory_invalid, memory_unsupported, memory_busy and memory_unavailable.

The chapter also fixes the control that matters most for a memory: what a memory returns is untrusted. A record written in one session is read in another, by another agent, for another person, so a server MUST present recalled content as data fenced from instructions and MUST carry written_by with it. Access is granted per memory, inherited downwards and additive — there is no deny — and the agent’s reach is checked by the server on every call, so an agent may walk the tree but never past what it was granted. See Memories.

What 2026-10-19 adds on the error envelope

Section titled “What 2026-10-19 adds on the error envelope”

2026-10-19 Errors §3.1 separates two moments that the previous version conflated:

MomentError codeStatus
The harness’s named model cannot be served on this harnessmodel_unavailable422
A harness create or update named a default_model its base does not runmodel_not_available422

A client that matched the old task-time code should match model_unavailable / 422. The messages are unchanged; only the code, the moment, and the namespace are. HarnessRouter v0.38.2 implements this split on the gateway side; the conformance suite at 2026.10.19.post5 exercises the F-09 retirement check — new in the 2026-10-19 suite — and carries T-12, the step-budget check, and F-10, the harness-create idempotency check, for 104 executable checks.

The same change ships the harness_retirement and input_history capabilities (see Lifecycle). Neither changes a security boundary a client relied on: a server that reports harness_retirement: false keeps its retired harness’s sessions readable, as every earlier version required, and a server that lacks input_history simply does not import earlier messages.

1. Authentication and authorization boundaries

Section titled “1. Authentication and authorization boundaries”

Review the effect boundary before exposing execution

Section titled “Review the effect boundary before exposing execution”

If your product also needs discovery, health, configuration and explicitly permitted control of agents, compare SAMP’s manager-to-agent plane with the execution boundary below. A management permission and a UHP admission token describe different operations; neither implies unrestricted downstream authority.

For a repository-editing service, trace identity and authority from the caller through the configured harness to every tool and result. A valid bearer token proves only the admission step it was issued for; it does not establish safe workspace configuration, trusted instructions or a harmless tool effect.

BoundaryEvidence to requireFailure to test
Caller → serverPrincipal and object scopeAnother principal’s harness/session/file cannot be reached
Server → configured harnessSelected runtime, model and effective permissionsUnknown or mismatched identity is refused rather than substituted invisibly
Harness → tools/processesActual declared tool surface and sandbox policyWorkspace instructions cannot silently grant undeclared authority
Shared project → sessionRead-only Environment mount and private writable workspaceA session cannot change a shared built layer or leak another session’s output
Result → clientTerminal cause and scoped artifact retrievalPartial or accepted work is not displayed as completed

Use workspace trust for configuration admission, tool-surface coherence for the model-visible interface and execution finality when acceptance must be distinguished from committed effects. The matrix is an integration review derived from the versioned UHP boundaries; the separate adjacent standards below do not replace those obligations.

The specification scopes authorization at the level of the principal that created an object, not at a per-endpoint granularity beyond authentication itself.

  • A server MUST authenticate every endpoint except GET /v1/uhp (the unauthenticated discovery document).
  • A server MUST NOT distinguish “no such token” from “token not permitted here” in a way that lets a caller enumerate valid tokens.
  • A server MUST NOT echo a credential — the caller’s or a provider’s — in any response body, error message, event, log line, or artifact.
  • A server SHOULD support revoking a credential, and revocation MUST take effect for new requests immediately.

Provider credentials (implementation guidance). The credential a server uses to reach a model provider is the most valuable secret in the system, and the agent’s own sandbox is the least trustworthy place in it. The specification therefore advises: do not place a provider credential where the agent’s tools can read it; if a harness must receive a credential, issue a short-lived, single-session one and be able to revoke it independently of the underlying key; and MUST NOT accept a caller-supplied upstream URL for a brokered request without validating it against a configured allow-list — an unvalidated upstream turns the server into an SSRF proxy carrying its own credential.

Emerging agent enrollment, identity, authentication, authorization, and assurance drafts — adjacent, not normative UHP

Section titled “Emerging agent enrollment, identity, authentication, authorization, and assurance drafts — adjacent, not normative UHP”

Agent enrollment, identity, authentication, delegated authority, per-action authorization, and pre-action assurance are moving quickly outside UHP. The following documents are useful to track because they target distinct trust layers around agent systems, but none is part of UHP and none is an IETF standard.

ProposalVerified statusRelevant mechanism
draft-ietf-wimse-aims-00 — AI Identity Management System (AIMS)Active WIMSE Working Group Internet-Draft; published 15 Sep 2026; draft header states Informational intent; work in progress. It replaces the earlier individual draft-klrc-aiagent-auth series.Treats AI agents as workloads and composes existing identity/security standards rather than defining a new wire protocol. AIMS spans identifiers, credentials/provisioning, transport/application authentication, OAuth delegation/authority, monitoring/remediation, policy and compliance.
draft-kavian-agent-enrollment-protocol-04 — The Agent Enrollment Protocol (AEP)Active IETF individual Internet-Draft; published 4 Sep 2026; intended status Standards Track; work in progress.Defines a narrow HTTP machine-first enrollment/bootstrap layer: unauthenticated /.well-known/aep inspection, DID-based agent identity enrollment, per-request client-assertion JWTs, status, optional session-credential grants and revocation. It explicitly excludes action authorization, KYC, payments/checkout and legal policy.
draft-wei-aic-identity-cert-02 + draft-wei-aic-jwt-02 — AI Agent Identity Certificate (AIC) X.509 and JWT profilesActive IETF individual Internet-Drafts; X.509 and JWT profiles both dated 2 Oct 2026; both have Experimental intent and no formal standing in the IETF standards process.Defines the same agent↔principal binding, capability/delegation and authorization-constraint model in two carriers: an X.509 v3 extension for transport/TLS and offline validation, plus a companion nested-JWS JWT profile for HTTP/web/OAuth contexts where client certificates are unavailable.
draft-chen-oauth-agent-authz-use-cases-03 — Agent Authorization use cases and gap analysisActive IETF individual Internet-Draft; published 25 Aug 2026; intended status Informational; work in progress; no formal IETF standing.Requirements/gap analysis rather than a protocol. It identifies recurring OAuth 2.x gaps for agent systems around authorization context, multi-hop delegation chains and mass/task revocation, plus dynamic/JIT authority, bounded constraints, cross-agent audit/task context, cross-domain delegation and execution-layer evidence.
draft-asor-wimse-agent-delegation-chain-01 — Verifiable Attenuated Delegation for AI Agent ChainsActive IETF individual Internet-Draft; published 3 Sep 2026; no formal IETF standing. The document header states Standards Track intent; work in progress.Defines an OAuth/JOSE Agent Delegation Chain for depth ≥2 delegation: RFC 9068 JWT access tokens carry RFC 9396 authorization_details, each child commits to its parent, holder binding uses DPoP, and an offline verifier enforces monotonic authority attenuation, bounded depth and monotonic expiry.
draft-prakash-aip-01 — Agent Identity Protocol (AIP): Verifiable Delegation for AI Agent SystemsIETF Individual Submission Internet-Draft; published 19 Aug 2026; intended status Informational; work in progressDefines Invocation-Bound Capability Tokens (IBCTs). Compact mode uses JWT with Ed25519 for single-hop interactions; chained mode uses Biscuit tokens with append-only blocks and Datalog policy evaluation for multi-hop delegation. The draft specifies bindings for MCP, A2A and generic HTTP.
draft-fane-opena2a-aip-03 — OpenA2A Agent Identity Protocol (AIP)IETF Individual Submission Internet-Draft; published 30 Sep 2026; intended status Standards Track; work in progressA separate OpenA2A identity/trust proposal using the same “AIP” abbreviation. Its design centers cryptographic agent identity, structured capabilities and trust signals.
draft-saha-aadp-04 — Agent Action Decision Protocol (AADP): Per-Action Authorization for AI AgentsActive IETF individual Internet-Draft; published 27 Sep 2026; document header states Standards Track intent; work in progress.Defines a two-phase authorization contract between a Policy Decision Point (PDP) and Policy Enforcement Points (PEPs), with machine-readable verdicts, fail-closed obligations, atomic budget reservations, approval lifecycle, idempotency and evidence. It is designed to compose with identity/token layers rather than replace them.
draft-zagarella-autonomy-governor-01 — Pre-Action Risk-Graded Assurance for Agent InteractionsIETF Individual Submission Internet-Draft; published 24 Aug 2026; intended status Informational; work in progressDefines a pre-action interface that derives a risk-graded assurance requirement, gates execution until that requirement is met, and records the decision for audit. Revision -01 also describes an informative autonomy-asymmetry reference design: failures raise assurance immediately (“fast-down”), while sustained verified success can relax it gradually (“slow-up”).

AEP fills a different gap from authorization protocols. It addresses the machine-first provisioning step by which an autonomous agent becomes enrolled and recognized by an HTTP service, then optionally bootstraps a session credential. Its baseline flow is Inspect → Enroll → Status → optional Grant → Revoke, with authenticated commands using an agent-signed client assertion. The draft explicitly leaves action authorization and policy decisions outside scope. UHP 2026-10-04 authenticates callers to a UHP server but does not define a cross-service agent-enrollment protocol, so AEP is adjacent identity/bootstrap work rather than a UHP extension or adoption signal.

AIC is a credential/profile proposal, not an enrollment service or general authorization protocol. The X.509 draft binds an agent cryptographic identity to a responsible principal and carries capability/delegation metadata and constrained authorization evidence that can be evaluated at the TLS layer; the JWT companion carries the same semantic model at the application layer and defines PKI- and OAuth-oriented issuance/exchange paths. Both documents explicitly remain individual Experimental Internet-Drafts, and their policy/capability semantics are not a universal authorization language. UHP 2026-10-04 does not define an AIC certificate/JWT profile or require AIC-style principal binding, so no UHP↔AIC dependency or adoption relationship is established.

The OAuth agent-authorization gap-analysis draft is a problem statement, not another authorization mechanism. Revision -03 explicitly says it does not propose new solutions or protocols. Its value is to make the problem surface concrete across personal, enterprise and security use cases: high-level user intent can become detached from later permission prompts; multi-agent delegation lacks a standard verifiable multi-hop chain; and incident response lacks standardized task/bulk revocation and common cross-agent audit context. Those gaps help explain why adjacent work such as AIMS/WIMSE, AuthZEN, XAA/EMA, AADP and delegation-token proposals exist, but the draft does not select or standardize any of them. UHP 2026-10-04 likewise does not define those cross-domain OAuth authorization semantics.

Google Cloud Agent Identity and auth manager — deployed adjacent implementation (checked 4 October 2026)

Section titled “Google Cloud Agent Identity and auth manager — deployed adjacent implementation (checked 4 October 2026)”

Google Cloud now provides a deployed identity and outbound-authentication stack for agents. Agent Identity became Generally Available on 22 April 2026 and assigns each deployed agent a unique SPIFFE identity plus a short-lived X.509 certificate. Google documents certificate-bound access tokens for Google Cloud access, OIDC ID tokens for direct external-service authentication, and audit attribution that can preserve both agent and end-user identity when the agent acts on a user’s behalf.

The 18 June release note concerns the Agent Identity API Preview, a separate milestone. On 22 August 2026, Google made Agent Identity auth manager and the Agent Identity APIs (agentidentity.googleapis.com and agentidentitycredentials.googleapis.com) Generally Available. The auth manager is a centralized credential vault and outbound-authentication broker for 3-legged OAuth, 2-legged OAuth and API keys. Google ADK can retrieve and inject credentials for external tool and MCP-server calls, while IAM policy can scope which SPIFFE-based agent principals may use each auth provider.

Credential exposure depends on the deployment path. The auth manager overview describes credentials returned to the agent/ADK for outbound calls; the Agent Identity overview separately describes a Gateway + Gemini Enterprise path in which end-user credentials are decrypted at the gateway and withheld from the agent. A centralized vault alone is therefore not proof that tools can never see a raw credential. Decommissioning also needs IAM cleanup: deleting an agent leaves its bindings behind, and a replacement gets a new principal even with the same display name.

Google’s MCP authentication guidance explicitly lists Agent identity alongside user and workload identities for Google and Google Cloud MCP servers. For production workloads, Google recommends a separate agent or workload identity instead of a human user identity so permissions can be limited and actions can be attributed independently.

The Agent Delegation Chain draft is one concrete response to that multi-hop delegation gap, but it is not an adopted WIMSE solution. draft-asor-wimse-agent-delegation-chain-01 profiles OAuth JWT access tokens so each delegated hop can only narrow authority relative to its parent and the ultimate enforcement point can verify the chain offline. Authority is expressed with RFC 9396 authorization_details; par_hash binds each child to one exact parent; DPoP binds a token to its holder; depth and expiry cannot expand downstream; and status-list machinery can be used for revocation. The draft says it is designed to satisfy the cross-organization delegation attenuation requirement, complement AIMS, and converge with existing attenuating-agent-token work. It remains an individual I-D with no formal IETF standing. UHP 2026-09-12 defines no equivalent cross-agent delegation-token chain, so this is adjacent authorization/delegation architecture rather than a UHP extension or adoption signal.

AADP targets a different layer from the AIP drafts. Its PEP sits where a governed action actually happens — for example a tool wrapper, protocol proxy, API gateway or runtime supervisor — and consults a PDP before acting. The draft defines autonomy tiers from read-only observation through reversible/capped autonomous action to human-confirmed execution, and its authorization decision depends on mutable state such as budgets, live reservations, approvals and a kill switch. A search of the current UHP 2026-10-04 protocol source finds no PDP/PEP or autonomy-tier contract; this is therefore adjacent security architecture, not a UHP extension or adoption claim.

The Pre-Action Risk-Graded Assurance draft addresses a narrower but distinct question: not simply whether an action is authorized, but how much assurance must be satisfied before that action proceeds. It defines common audit semantics across human re-authentication, agent-action oversight and computational-resource selection. Its -01 autonomy-asymmetry loop uses VERIFY outcomes as feedback, escalating assurance immediately after failure and allowing relaxation only after sustained success. The draft presents that loop as an informative reference design; concrete risk scoring, thresholds and control mapping remain deployment choices. UHP 2026-09-12 defines no equivalent assurance-grading or adaptive-autonomy contract, so this remains adjacent governance/security work rather than a UHP feature.

Verifier binding: identity, authority, session state and evidence are different claims

Section titled “Verifier binding: identity, authority, session state and evidence are different claims”

A new protocol-neutral review draft makes a useful boundary explicit. draft-bu-agentproto-security-principal-binding-07 — Security Principal and Verifier Binding for Agent Communication Protocols was published 15 September 2026 as an active individual Internet-Draft with Informational intent and no formal IETF standing. It does not define another agent protocol, token format, authorization system, audit log or transparency service. Instead, it defines a claim-to-verifier discipline for reviewing agent protocols and their security evidence.

The core rule is that a carrier is not the claim it carries, and one verified claim must not silently upgrade into another. The draft separates human/organizational authority, live agent-instance identity, tool/resource identity, delegated authority, session continuity and action evidence. For each security-relevant row, the reviewer records the claim, carrier, verifier, binding, freshness rule, failure behavior and accepted result, then keeps specification status, implementation status and evidence type/coverage separate. A successful verifier should therefore return only the constrained fact it established — for example, session-bound token possession — rather than an implied conclusion such as “the target action is authorized.”

Revision -07 further makes composition review structural: dependency closure prevents an aggregate result from becoming stronger than its verified inputs; machine-readable mappings bind stable row identifiers to exact row artifacts; unresolved freshness/failure checks remain distinguishable; and parsing or reproducing a same-source artifact is classified as local consistency rather than independent verification. The draft also states the inverse explicitly: carrying or forwarding a receipt, attestation, pointer or other artifact is not the same as verifying its authority, provenance, current status, independence or policy sufficiency.

For UHP, this is external review guidance, not normative protocol behavior. It is nevertheless a useful discipline when evaluating authentication, principal-scoped objects, sessions, delegation systems and runtime-evidence integrations around a UHP deployment: a UHP session id is not delegated authority, a signed evidence record is not authorization, and implementation/test evidence for one revision should not silently upgrade another revision or another security claim. No UHP↔principal-binding protocol dependency or native adoption is established.

Runtime verification, signed action receipts, and effect-boundary evidence — adjacent, not normative UHP

Section titled “Runtime verification, signed action receipts, and effect-boundary evidence — adjacent, not normative UHP”

Three August/September 2026 Internet-Drafts make a per-action accountability stack more explicit: runtime evidence generation, signed action recording/transparency, and executor-side evidence consumption/enforcement. They are adjacent proposals, not UHP requirements or IETF standards.

ProposalVerified statusRelevant mechanism
draft-correctover-ccs-09 — Correctover Conformance Shape (CCS): Runtime Verification for AI Agent Tool CallsActive IETF individual Internet-Draft; published 14 Sep 2026; intended status Experimental; work in progress. The current text records one reference implementation in two deployment forms plus one independently developed third-party interoperability profile.Defines seven runtime-verification dimensions (Structure, Schema, Latency, Cost, Identity, Integrity, Security), a receipt with detached Ed25519 signatures over RFC 8785 canonical JSON, three verdicts (allow, deny, escalate) and four executor lifecycle states (confirmed, dispatched, indeterminate, unknown). Revision -09 makes the draft self-contained: AEB and CAID move to Informative References while the native artifact requirements they motivate are restated normatively inside CCS.
draft-noa-scitt-ai-agent-receipt-01 — A SCITT Profile for AI-Agent Action ReceiptsInternet-Draft in the SCITT work area; published 15 Aug 2026; intended status Standards Track; work in progressProfiles the published SCITT architecture (RFC 9943) for one signed record per governed agent action. A receipt carries the action, recorded principal class, recorded verdict and optional policy identity; it is hash-chained, can be carried bare or in COSE_Sign1, and can be registered as a SCITT Signed Statement with a Transparency Service. The profile explicitly does not prove correctness, complete or true inputs, prior authorization, downstream success or physical effect.
draft-schrock-action-evidence-boundary-07 — The Action Evidence Boundary for Consequential Agent Effects (AEB)IETF Individual Submission Internet-Draft; published 25 Sep 2026; intended status Informational; work in progressDefines an executor-side ordered processing model: native artifact verification → exact-action correlation → evidence satisfaction → separate local authorization → durable consumption/reservation → dispatch/invocation → closed effect outcome or authenticated reconciliation. It deliberately defines no new receipt/token format, policy language or registry.

The current AEB -07 strengthens uncertain-effect handling with a durable same-action fence: fresh authority or a different evidence path cannot admit another attempt while the previous one is in flight or uncertain. Release before provider entry requires proof that entry never occurred. This addresses duplicate effects after ambiguous dispatch; it is separate from receipt signature validity and from the UHP request-idempotency capability.

CCS -09 keeps the evidence profile distinct from authorization while making its own conformance requirements self-contained: AEB and CAID are now informative references, and the native artifact requirements previously motivated through them are stated normatively within CCS itself. The current draft retains detached Ed25519 signing over RFC 8785 canonical JSON and clarifies that its implementation experience is one reference implementation in two deployment forms plus one independently developed third-party interoperability profile. CCS produces and propagates runtime verification evidence. The SCITT Action Receipt profile standardizes a signed record of what was recorded at the governed boundary and, when registered, lets a SCITT Transparency Service add independently auditable transparency; the draft explicitly names AEB as adjacent rather than a dependency. AEB then defines the executor-side ordering needed before and after a consequential effect. A verified receipt therefore must not be substituted for authorization or proof that the external world changed.

UHP 2026-10-04 does not define a CCS-style runtime-evidence contract, a SCITT COSE_Sign1 per-action receipt / transparency-registration profile, or an AEB-style effect-boundary composition contract. UHP events can expose tool activity within the task lifecycle, but that is a different concern from signed action evidence, transparency and executor-owned one-time effect control. These drafts are also distinct from ATIF, which standardizes portable whole-trajectory records for evaluation/replay rather than per-action verification evidence or enforcement ordering.

OpenID AuthZEN authorization profiles — adjacent, not normative UHP

Section titled “OpenID AuthZEN authorization profiles — adjacent, not normative UHP”

The OpenID AuthZEN Working Group now provides a more mature standards path for externalized authorization than the independent Internet-Drafts above. Authorization API 1.0 is an OpenID Final Specification, published 11 Jan 2026 in the specification header and standardizes the PEP-to-PDP decision exchange. Two newer Working Group drafts extend that base in ways directly relevant to autonomous agents and MCP, but neither is a UHP requirement and neither changes the UHP 2026-10-04 security contract.

AuthZEN workVerified statusRelevant mechanism
Authorization API 1.0OpenID Final Specification, published 11 Jan 2026Standard PEP ↔ PDP authorization requests and decisions using the Subject-Action-Resource-Context (SARC) model.
Access Request and Approval Profile (ARAP) — current working draftOpenID AuthZEN Working Group draft; Standards Track labelKeeps a denied decision denied, but lets a machine-readable requestable denial start an asynchronous access-request task. Approval does not itself grant access: the PEP re-evaluates through the PDP, which remains authoritative at enforcement time. The profile explicitly targets autonomous callers that discover new resources or authority requirements during long-running work.
COAZ-MCP — Draft 1OpenID AuthZEN Working Group draft; Standards Track label; published 13 Feb 2026Binds MCP JSON-RPC messages to AuthZEN decisions. It defines default mappings for MCP methods and optional per-tool x-authzen-mapping declarations, allowing an MCP gateway or server to act as the PEP and consult an AuthZEN PDP before an MCP message takes effect.

These documents solve different pieces of the authorization stack. COAZ-MCP maps what an MCP operation means for policy evaluation; ARAP standardizes what happens after a denial is requestable and requires asynchronous governance. AADP independently proposes a stateful per-action authorization protocol with budgets, reservations and approval lifecycle. They should not be collapsed into one protocol family merely because all use PEP/PDP terminology.

Cross-App Access and MCP Enterprise-Managed Authorization — adjacent, deployed

Section titled “Cross-App Access and MCP Enterprise-Managed Authorization — adjacent, deployed”

Cross-App Access (XAA) is the application-ecosystem name for a delegated OAuth pattern in which an application obtains access to another application’s API through an Identity Provider (IdP) both sides already trust for SSO. The current IETF OAuth Working Group document draft-ietf-oauth-identity-assertion-authz-grant-04 realizes that pattern with an Identity Assertion JWT Authorization Grant (ID-JAG). It remains an active Internet-Draft / Working Group document, not an RFC. The underlying draft-ietf-oauth-identity-chaining-17 is likewise still an Internet-Draft, although it has advanced to the RFC Editor queue with Proposed Standard intent.

MCP applies that pattern through its stable Enterprise-Managed Authorization extension (io.modelcontextprotocol/enterprise-managed-authorization). The MCP client asks the enterprise IdP for an ID-JAG and exchanges it at the MCP server’s authorization server for a scoped access token; policy and revocation can therefore remain centralized at the enterprise IdP. This is current MCP extension behavior, not merely a roadmap item.

On 24 Aug 2026, Okta announced General Availability of Agent SSO, powered by XAA. Okta says the product models XAA-supported agents as first-class identities and replaces hard-coded credentials/broad OAuth authorizations with short-lived, identity-governed tokens for sanctioned applications, APIs, tools and MCP servers. That is concrete implementation/adoption evidence for XAA/EMA, not a UHP requirement and not evidence of UHP adoption.

XAA/EMA and AuthZEN solve different problems and can coexist. XAA/EMA governs cross-domain token acquisition and enterprise IdP-mediated delegation; AuthZEN externalizes authorization decisions between a PEP and PDP. Neither standardizes UHP’s client-to-harness execution contract.

The MCP Core Maintainers’ 22 August roadmap independently prioritizes further agent identity/delegation and enterprise security work such as DPoP, Workload Identity Federation and token exchange. Those roadmap items are future-direction signals; the already-stable Enterprise-Managed Authorization extension should not be downgraded to roadmap-only status.

HTTP route-scoped credential proof: x401 — adjacent draft, not normative UHP

Section titled “HTTP route-scoped credential proof: x401 — adjacent draft, not normative UHP”

x401 0.2.0 is a Draft HTTP proof-requirement protocol for a different question from authentication or action authorization: what credential-backed attribute must be proved before this specific HTTP resource can be accessed? Examples in the specification include personhood, residency, membership, accreditation, entitlement, organizational standing and workload-identity attributes.

The Verifier carries a composed Digital Credentials API request in PROOF-REQUEST, using OpenID4VP/DCQL to describe the required credential evidence. The Agent obtains the credential result from a local or remote Credential Manager and retries the protected route with PROOF-RESPONSE; PROOF-RESULT carries x401-specific verifier outcomes. A deployment may optionally exchange a successfully verified result for a short-lived OAuth token so the presentation does not have to be repeated on every request.

UHP 2026-10-04 authenticates callers and scopes UHP objects, but it does not define a machine-readable route-level credential-proof challenge for attributes such as residency or accreditation. An HTTP deployment could in principle place an x401 gate around a UHP-facing or adjacent resource, but this guide has verified no standardized UHP↔x401 binding, dependency or adoption relationship.

  • Every object — harness, response, session, container, file — MUST be scoped to the principal that created it.
  • A request for an object outside the caller’s scope MUST return 404, never 403. A 403 confirms the id exists, which is exactly what an enumerating attacker wants (Architecture §5).
  • Scope MUST be enforced on every operation, not only on read. Cancel, delete, continue, and download are all object access.

Implementation guidance. The conformance suite cannot fully verify scoping with a single credential. An implementer SHOULD run the equivalent check with two principals: create an object as A, then attempt every operation on it as B, and confirm each returns 404.

An agent can be persuaded to write a file with chosen content and a chosen name, so everything that serves artifacts MUST treat them as hostile.

  • Artifact downloads MUST be served with X-Content-Type-Options: nosniff; without it, an artifact named x.html becomes stored XSS against the client’s own origin (Files §3).
  • Artifacts SHOULD be served from a different origin than the console or application UI, so a successful injection cannot reach first-party cookies or storage.
  • A server MUST NOT allow a container_id / file_id pair to address anything outside its container. Path traversal through artifact ids is called out as the most likely serious vulnerability in a UHP implementation; the conformance suite probes for it (X-08).
  • A server SHOULD cap artifact size and count per session.

Browser network policy depends on who owns the browser

Section titled “Browser network policy depends on who owns the browser”

HarnessRouter’s v0.29.0 self-hosting guide distinguishes the provisioned service from an operator-supplied Chrome DevTools Protocol endpoint configured through HR_BROWSER_CDP_URL.

Browser modeNetwork boundaryOther relevant limits
Provisioned/vendor browserRefuses private, loopback, link-local and cloud-metadata targetsVendor session/limits and supported Console live view
Operator’s own Chrome via CDPCan reach the operator’s network; vendor private/local refusal is liftedSite allow/deny lists still apply; separate context per task; no vendor metering or Console live view

An isolated browser context separates cookies and tabs; it does not establish a network-isolation boundary. Review the CDP endpoint’s exposure and the host’s network authority before enabling this mode. The vendor refusal must not be presented as a guarantee for an operator-owned browser, and neither mode is a normative UHP sandbox requirement. See Runtime Plugins for the setup and service-plane distinction.

  • error.message MUST be safe to show a user: no credentials, internal hostnames, file paths, or stack traces (Errors §1).
  • A server SHOULD log the detail it withholds, returning a correlation id in error.detail so an operator can diagnose what a caller cannot see.
  • (Repeated from §1) a server MUST NOT echo any credential in a response body, error message, event, log line, or artifact.

5. Harness, tool, and prompt-injection risk

Section titled “5. Harness, tool, and prompt-injection risk”

A harness that reads a web page, a repository, or an uploaded file may encounter instructions addressed to it. UHP cannot prevent this, and the specification says so plainly rather than pretending otherwise.

What the protocol provides, and a client SHOULD use:

  • disabledTools on a configured harness — the smallest tool set is the smallest injection surface.
  • max_step and timeout_seconds — a bounded task cannot be induced into an unbounded one.
  • Separate harnesses for separate trust levels; a harness that reads untrusted input SHOULD NOT be the same configured harness that holds privileged tools or MCP servers.
  • The event stream — tool calls are visible as they happen, so a client can surface or gate them.

A server MUST NOT claim that any of this makes an agent safe to point at untrusted input. Prompt-injection resistance is the client’s responsibility, not a protocol guarantee.

Shell parsing is an authorization boundary — source-pinned Qwen evidence

Section titled “Shell parsing is an authorization boundary — source-pinned Qwen evidence”

A shell permission rule is only as sound as the parser that decides which commands the shell will actually execute. Qwen Code PR #11765, merged on 23 September 2026 as 7e568a2c586e9c7b3c87ed38cacdca81297cac4a, fixes a concrete fail-open mismatch in compound-command segmentation. With only Bash(echo *) allowed, a command such as echo 'a\' ; touch /tmp/qwen-poc could previously be treated as one allowed echo segment even though Bash executes touch as a second command. Because the second command never became its own policy segment, an explicit deny rule for that second command could also be bypassed.

The root cause is a useful general harness-security pattern: the policy parser and the execution interpreter disagreed about quoting semantics. In plain Bash single quotes, a backslash is literal; it does not escape the closing quote. Qwen’s pre-fix splitter treated the backslash as an escape and therefore lost the real command boundary. PR #11765 distinguishes plain single quotes from ANSI-C $'…' quoting and scans under both the corrected and pre-fix readings, splitting wherever either reading finds an operator. That makes the security boundary monotonic relative to the prior parser: the new segmentation may be more conservative, but it is not allowed to lose a boundary that the old reading would have enforced.

This produces a reusable design rule for agent harnesses that offer shell allow/deny policy:

  1. Authorize executed segments, not a display string. Permission evaluation must operate on the same security-relevant command boundaries the shell will execute.
  2. When parser equivalence is incomplete, fail closed. If the policy layer cannot model comments, heredocs, backticks, substitutions or quoting exactly, uncertainty should lead to an ask/deny or conservative extra boundary rather than silently merging commands into an allowed prefix.
  3. Deny evaluation needs the same visibility as allow evaluation. A parser bug that hides a trailing command can bypass both an allow prompt and an explicit deny rule.
  4. Track state changes from real executable segments. False parsing of a non-executed cd can also corrupt working-directory or write-target attribution even when it does not directly widen permission.
  5. Use the real shell as a differential oracle. Policy parsers should be fuzzed and regression-tested against the interpreter they are trying to constrain, with mutation tests for each boundary rule.

The fail-closed trade-off is real. The upstream PR explicitly records comment/heredoc/backtick cases where scanning both readings can create a false deny or false ask even though Bash would execute only one command. It also leaves command substitution, environment-variable tricks and spellings that fool both readings out of scope. Upstream reports 553 permission-manager tests passing, 1,656 tests across the permission/shell/monitor/shell-utils suites, mutation guards for the new parser branches and a 150,000-line differential fuzz; direct local validation was on macOS, while Windows and Linux were not locally run by the contributor.

Harness Plugins: third-party code is an execution boundary

Section titled “Harness Plugins: third-party code is an execution boundary”

UHP 2026-09-12 adds normative security rules for optional Harness Plugins. A plugin can contribute instructions and executables written by a third party, so installing one extends the harness’s trust boundary to the plugin author.

  • A stdio MCP server declared by a plugin MUST run inside the same sandbox that runs the agent, with no more privileges than the agent. It MUST NOT run on the server host and MUST NOT be launched through a shell.
  • A server MUST expand only ${PLUGIN_ROOT} and ${PLUGIN_DATA}, only in args, env, and cwd; it MUST NOT perform other placeholder or environment-variable expansion for plugin launch configuration.
  • A plugin command or cwd that resolves outside the plugin root is invalid rather than a permitted escape.
  • Plugins are installed by whoever manages the harness (Full class), never per request. A request may narrow tools; it must not widen the execution surface by introducing a plugin or MCP server.
  • A skill inside a plugin is prompt content and remains subject to the prompt-injection boundary above. Before installation, a client SHOULD show the manifest’s author, homepage, and repository, and after installation it SHOULD surface components reported as skipped.
  • A server exporting a harness as a plugin package MUST omit auth and headers; an exported package is intended to leave the server boundary.

These are UHP protocol requirements for plugin-capable implementations, not claims that a plugin is safe, reviewed, signed, or trustworthy merely because its package is valid.

Environments: shared state needs enforced isolation

Section titled “Environments: shared state needs enforced isolation”

UHP 2026-10-04 extends the security contract to Environments. The Security chapter at v0.29.0, checked 4 October 2026, requires:

  • an enforced read-only Environment mount; an instruction asking the agent not to write is insufficient;
  • builds running with a task’s toolchain, network and privileges, without access to other Environments or sessions;
  • confinement of file paths, archive members and repository trees to the Environment root, with escaping links and absolute paths dropped.

Deployment review: test both the build and the running session boundary. A successful read-only task test alone does not establish that a build script cannot reach another tenant. Keep generated output in the session workspace; do not promote it into a shared Environment without the owner’s intended build/publication operation. These checks are implementation guidance, not additional UHP endpoints.

  • A server MUST bound task duration, and MUST report incomplete rather than completed when a budget stopped the work (Lifecycle §3).
  • A server MUST refuse a second concurrent task in the same session (session_busy) — two agents in one working directory is not a defined state and is also a cheap way to multiply cost.
  • A server SHOULD rate-limit task creation per principal and SHOULD expose remaining budget through rate_limit_error responses rather than failing opaquely.
  • A server MUST bound upload size and reject with file_too_large rather than truncating; a silently truncated input produces a confident, wrong answer.

7. Cancellation, retry, duplicate execution, and idempotency

Section titled “7. Cancellation, retry, duplicate execution, and idempotency”

These concerns are governed by several chapters together. The normative facts:

  • Cancellation. A running task is cancelled with POST /v1/responses/{response_id}/cancel and a running session with POST /v1/sessions/{session_id}/cancel; deleting a session (DELETE /v1/sessions/{session_id}) cancels any in-flight task first; /v1/traces/{session_id} is a compatibility alias. A server MUST refuse a second concurrent task in the same session, which also prevents duplicate concurrent execution (§6).
  • Idempotency. When the idempotency capability is advertised, a submit can carry an Idempotency-Key header so a retried submission does not create a duplicate task (Tasks chapter).
  • Retry. A conformant client MUST treat an unknown error code as its type; an unrecognised server_error is still retryable, and rate_limit_error exposes remaining budget rather than failing opaquely (Versioning client rules).

Interpretation: idempotency and the single-concurrent-task rule are the protocol’s mechanisms against accidental duplicate execution; they are controls on the request/response contract, not on the agent’s internal behaviour.

  • TLS MUST be used except on loopback.
  • A server SHOULD send Strict-Transport-Security.
  • A server serving any HTML MUST send X-Frame-Options: DENY or an equivalent frame-ancestors 'none' policy.
  • Session artifacts and transcripts MUST be unreachable after the session is deleted.
  • A server SHOULD document its retention period. “Indefinite” is an answer; silence is not.
  • Session sharing, where implemented, MUST be read-only and revocable, and MUST NOT expose credentials or another principal’s data (Sessions §5).

10. Client and server trust responsibilities

Section titled “10. Client and server trust responsibilities”
PartyResponsibilities stated by the specification
ServerAuthenticate all endpoints but discovery; never echo credentials; scope every object to its creator and return 404 (not 403) for out-of-scope access; serve artifacts with nosniff from a boundary that contains traversal; keep error.message safe and log the withheld detail; bound task duration, concurrency, and upload size; use TLS and frame-protection; erase artifacts on session deletion; make sharing read-only; sandbox plugin stdio MCP servers, constrain plugin expansion/path resolution, and omit auth/headers from exported plugin packages.
ClientTreat prompt injection as in-scope; configure least-privilege harnesses (disabledTools, max_step, timeout_seconds, separate trust levels); monitor the event stream; retry unknown server_error codes and honour rate_limit_error; use Idempotency-Key when offered; verify scoping with a two-principal test; review plugin provenance fields and surface skipped plugin components.

Vulnerabilities in the reference implementation or in the specification follow private disclosure, not a public issue; see the repository’s security policy. A specification bug that makes a secure implementation impossible is treated as a vulnerability, not as a documentation defect.

The reference implementation now publishes its own security review — adjacent, development main

Section titled “The reference implementation now publishes its own security review — adjacent, development main”

The reference implementation’s repository added a Community Edition security review — a threat model for the self-hosted product — and the files that prepare it for an opt-in open-source vulnerability scanning program. Both arrived on upstream main in one commit, e94398d9c91a (PR #617, merged 31 October 2026), which is one commit ahead of the stable v0.37.13 tag and is not part of any release. The maturity boundary matters more than the file list: committing these files does not enroll the project, start a scan, or grant access to a model API.

What the review covers. The threat model scopes the public code — gateway/, runner/, ui/, protocol/ and their adapters — as the self-hosted Community Edition. It explicitly excludes hosted services, real provider accounts, deployments belonging to other people, and third-party agent CLIs, SDKs and dependencies, which have their own maintainers; integration mistakes in the project’s own code remain in scope, and an already-compromised host is outside the model. It describes the one-container layout the review assumes — the console publishes only port 3000, the gateway and the runner listen on loopback, the runner runs as root only so that each agent session runs as its own uid, and the runner’s environment carries neither the login nor the secret-store key — and it names the boundaries it prioritises: untrusted request bodies, identifiers, paths, filenames, archives and streamed events entering the gateway or runner; authentication and access checks before reading credentials, changing an instance’s configuration, or operating on another session’s resources; file containment, traversal, symlinks and generated-artifact access; credential forwarding into logs, errors, subprocess environments and proxy destinations; the difference between an agent’s intended workspace authority and access to unrelated sessions, instance configuration or host resources; and UI rendering of untrusted files and agent output. The published default password and HR_AUTH_DISABLED=1 are the operator’s choices, and the startup log warns about both — as the review of 31 October 2026 described them. That is no longer the whole picture: the v0.37.15 release below stopped accepting the published default console password.

What the scanning preparation is, and is not. The enrollment payload points the scanner at the repository’s main branch, at a repository-hosted Dockerfile and at that threat model, and names the contact address that the repository’s security policy already publishes. The audit image keeps the full source tree in /src, installs dependencies at build time and builds the self-hosted UI, but does not start the application, authenticate to providers, or run the first-boot CLI installer. The offline check runs the repository’s own test suites with --network none; the preparation’s pull request reports 170 passing — gateway 11, runner 1, protocol 158 — and the accompanying note says plainly that a green run means a patch can be tested offline in the image, not that the code is secure. A workflow validates the payload against a pinned upstream validator, builds the image and runs that offline check on main and weekly; it checks the environment only, and does not submit an enrollment or invoke a model scan. Enrollment itself is a separate, maintainer action: it must be submitted by a core maintainer who is, or is authorised by, the lead maintainer, with the program’s agreement and its contribution and licence requirements reviewed first, and acceptance is at the program’s discretion. The project is therefore not enrolled, and no scan has run. What enrollment would provide, if it happened, is free periodic scans at a frequency the program sets, with model-generated findings that require maintainer validation and patches that are suggestions for review — and it would not replace dependency scanning, branch checks, runtime monitoring, or the maintainers’ own vulnerability-response process.

This is adjacent implementation evidence, not a UHP requirement and not a certification: the protocol’s own security obligations are unchanged, and this guide’s documented-versus-interpretation table still applies.

The reference implementation closed every path from an agent turn to a credential — adjacent, released in v0.37.15

Section titled “The reference implementation closed every path from an agent turn to a credential — adjacent, released in v0.37.15”

HarnessRouter v0.37.15 (3 November 2026) is a security release, and the finding behind it is the shape of the risk rather than a single bug: an agent turn runs with real shell access, and everything it can read is also readable by anything that reaches the agent, such as a prompt injection. The release closes every path it found from a turn to a credential.

  • Provider keys — every key, including the image-generation credential and the Bedrock and Vertex credentials — now stays in the runner’s relay. A turn receives the relay’s address and a placeholder on every base and every kind of connection: the relay signs Bedrock requests, mints Vertex access tokens, accepts only a path and never follows a redirect. A test builds every base’s turn for every connection shape with a canary key and fails if that key appears anywhere the turn can read.
  • The instance’s own secrets no longer travel with git or the other processes the runner starts for a session, and hooks the agent leaves in its repository no longer run.
  • Files outside the session are protected by writing into the session’s folder with the session’s own permissions, so a link the agent planted cannot redirect a write or a cleanup elsewhere.
  • Other sessions are protected by sending the jobs that need one privately instead of on a command line another session could read.
  • Saving an integration no longer lets a stored key follow a changed address or provider: the key is retyped when its destination changes.
  • There is no default password any more. The published default console password is no longer accepted; an instance without a password of its own makes one at first start, readable with docker exec <container> cat /data/selfhost-initial-password, and the compose file now publishes the console on that machine only.

Three advisories are published with it: GHSA-cww9-m4gr-cmw5, GHSA-m479-gmx7-8r8h (reported by Omer Bar-Ness, MergeSafe) and GHSA-r37g-f5m3-523c (reported by AkshatJoshi2000). The release’s own advice is to rotate provider keys after upgrading if untrusted people can start turns on the instance or the agents read untrusted content. The starter kits shipped in the image are rebuilt with every critical and high advisory closed — xlsx 0.20.3 pinned by checksum for the Sheets and Harness Bot kits, DOMPurify 3.4.17 for Slides and Video, and vite 6.4.5 for every kit.

This is the reference implementation’s own boundary work, reported here as implementation evidence. It does not change UHP’s normative security requirements, and it is not a certification of any deployment.

Two further security releases closed critical issues in one night — adjacent, released in v0.37.16 and v0.37.17

Section titled “Two further security releases closed critical issues in one night — adjacent, released in v0.37.16 and v0.37.17”

HarnessRouter shipped v0.37.16 (3 November) and v0.37.17 (3 November, 23:16 UTC) on the same evening as the v0.37.15 release described above, and both are security releases. A self-hoster needs all three.

An API key could read any file as root (v0.37.17). A marker file in a session’s folder could point the file routes at any folder on the machine, and a caller’s own PUT could set it — with no agent involved. That reached the instance’s internal key HR_SECRET_KEY, the stored provider keys and the databases, and a follow-up turn on Codex through its app server could also write through a link an agent left behind. Only the value the runner writes itself counts now, and these reads and writes run as the session. Upgrading does not undo a read that already happened, and the logs cannot show one. The release’s own remediation list is therefore a credential rotation, not only an upgrade: change HR_SECRET_KEY and the console password, replace the stored provider keys and any passed in the environment, reissue the API keys, then restart.

File routes refuse dot paths (v0.37.17). Every route on a session’s files — read, write, move, mkdir, delete, file ids, the listing, the archive and share links — now refuses a path with any segment that starts with a dot, and refuses a link that lands on one. That covers the runner’s state, git’s folder, every CLI’s folder and any credential file, including one an older version left behind, without depending on a list of names. Before this, the listing, the archive and share links also served a dot file inside a folder such as sub/.env, so anyone holding a share link could read one. What changes for a reader: an app can no longer read or write .env or .gitignore in a session through the API, and such a file is not listed or downloadable — while the agent itself still works with them, and an agent can still copy a file it can read into an ordinary file.

Root no longer runs what the product user can change (v0.37.17). The gateway and the console run as agent, but that user owned files root runs, so a bug in either could become root at the next restart. /app is now root’s, root has its own HOME, and on the data volume root keeps its folders where agent cannot move or replace them; the release gate checks this on a running container.

The console’s image optimizer is off (v0.37.16). It was reachable with no sign-in through published Next.js remote-code-execution bugs (GHSA-2464-fhr4-w9xw, GHSA-2xp9-vwfh-vxw4); Next.js and its image library are updated, and since the console does not use the optimizer it is now off. The same release hardens MySQL and MariaDB connections against a hostile database server, stops a build’s own code from planting a link that makes the runner write or read a file as root, reads a read-only database statement the way the database does, sandboxes an agent’s HTML and SVG files opened through the console, ends a relay route with its turn so a process left running cannot keep spending a connection’s key, and stops a browser-plugin host answering a public address once and a private one afterwards. On a cloud VM an agent’s shell can still reach the provider’s metadata address, which with an instance role means the role’s credentials — nothing inside the container can stop that, and the self-hosting guide now carries the one host command that blocks it.

The 0.38 line moved the credential boundary, and the licence text with it — adjacent, released in v0.38.0 to v0.38.2

Section titled “The 0.38 line moved the credential boundary, and the licence text with it — adjacent, released in v0.38.0 to v0.38.2”

MCP credentials stay out of the session (v0.38.0). A remote MCP server’s address and credentials now stay in the server; the session gets a local address holding one token that stops working when the turn ends. Before, most bases wrote the bearer token and the address into a config file in the session, where the agent could read it, and some of those files travel in the checkpoint. Rotate MCP tokens if an agent you do not fully trust has run on the instance — older sessions, checkpoints and their git history keep the copies they already hold, and the release does not remove them.

Stored credentials are encrypted at rest on every install (v0.38.0). An install with no HR_SECRET_KEY now gets one at its first start, kept in /data/secret-key (root’s, mode 600), and records stored in plain text are encrypted at that start. Four limits are the release’s own: this protects a copy of the secret store, not a copy of the whole volume, because the key sits beside the data — to keep them apart, set HR_SECRET_KEY to the value in that file and delete the file; do not set a new value over a generated key, because it cannot open what is already stored and the log says how many records it cannot open; back up /data/secret-key with the volume, because rolling back to an older image needs its value in HR_SECRET_KEY; and a token left on a harness moves the first time that harness is read, so one nothing reads keeps it until then.

A session’s reads and writes no longer carry group root (v0.38.1). The server takes on the session’s user and group, but through v0.38.0 it also kept root’s supplementary group, so an agent could use a link to reach what gid 0 can reach — reading a file only group root can read, such as one with mode 0640 owned by root, or overwriting a file group root can write. On the default image this reaches very little: four empty lock files under /var, and creating files in /usr/share/man/man1, man5, man7, man8 and /var/cache/debconf/tmp.ci; no file under /data, and no existing file could be overwritten. A volume you mount can hold more: if you mount files or directories group root can read or write, and an agent you do not fully trust has run there, treat what they hold as exposed — check them, and rotate any credential among them. Each release now fails its check if the server holds a supplementary group.

A task that cannot start says why (v0.38.1). A link at one of the session’s config paths used to make a follow-up wait about five and a half minutes and then report that no connection serves the model, which was not the reason; it now fails in under a second and says a file in the workspace cannot be written. Any other failure to start now says the task could not start, and no longer blames the connections.

A question asked of the person is constrained (v0.38.1). A confirm has to offer both answers, or none for yes and no — a lone yes is refused and the agent is told why — and the question’s text and the option’s id are quoted when the answer goes back, so a question cannot pass off its own words as a message from the person.

The image’s licence text was wrong, and is now checked (v0.38.2). The image shipped an LGPL library with no licence text beside it — Next.js lists sharp as optional for its image optimizer and the build copied @img/sharp-libvips-* (LGPL-3.0-or-later) in, though the console has never used that optimizer — and NOTICE said everything bundled was under a permissive licence, which was not true: it listed only direct dependencies. The image also did not carry LICENSE or NOTICE, though NOTICE says it travels with a copy. Now sharp and its native libraries are gone, NOTICE is corrected and names certifi (MPL-2.0) and Pyphen (offered under GPL, LGPL or MPL, used under MPL), and the image carries /app/LICENSE, /app/NOTICE and /app/THIRD-PARTY-console.txt with the licence text of every console package. scripts/check-licenses.py runs in the tests and inside every release’s image, on both architectures, and fails on anything that is not under a permissive licence and is not named with a reason. Code under any other licence is used only as the whole, unchanged package named in NOTICE.

Every release is now checked for the credential boundary (v0.38.0). Each release runs one task per base with a planted value in every credential and fails if one reaches a session, the volume or a response; the check is scripts/secret-canary-gate.py. What it does and does not cover is the upstream’s own subject: during a turn an agent can still use what it is given, and a stdio server’s values and a harness’s variables stay readable to it.

A turn now answers only the session that started it — adjacent, development main

Section titled “A turn now answers only the session that started it — adjacent, development main”

Two changes on the reference implementation’s main (6 November 2026, after the v0.38.2 tag) narrow a turn’s reach to the session that started it. Both shipped in v0.38.3 (7 November 2026), so they are released behaviour now, and they are worth naming because the boundary they close is exactly the one a shared runner gets wrong: a session holds a turn’s identifier, and nothing in a turn’s record says which session asked for it.

A turn is answered only to its own session. GET /turn/{id} and POST /turn/{id}/cancel now take the identifier the gateway already sends on every runner call, and a turn started by another session reads as no turn at all (404). A turn recorded without an identifier answers as before. The upstream notes the hardening is only on the runner’s internal routes: on a shared runner every route already requires the internal key, which no session process holds.

An idempotency key dedupes within its own session. The runner’s dedupe map is keyed by session and key, so a retried request from the same session still returns its running turn, while another session that sends the same key starts its own turn instead of being answered with that turn’s id, status and model. The 2026-10-19 specification leaves the key’s scope to the client — the key is a “client-generated-unique-string” and the server must, for a repeated key, return the first request’s result — so a client that reuses one key across sessions is misusing it, and the implementation now contains the mistake instead of the other session’s turn.

Together these close a cross-session information path: before them, a key collision between two sessions could hand the second session the first session’s turn identifier, status and model.

Documented (explicit in 2026-10-19)Not stated — do not assume
Authentication on all endpoints but GET /v1/uhp; no credential echo; token-enumeration resistance; immediate revocation.A specific auth scheme, token format, or MFA requirement.
Per-principal object scoping with 404 (not 403) for out-of-scope; traversal contained to the container.Per-object ACLs, role-based access control, or tenant isolation beyond principal scoping.
nosniff on artifacts; different-origin serving advised; size/count caps advised; safe error.message.A content-security-policy mandate or a specific artifact-scanning requirement.
Tool-injection controls via harness config; server must not claim safety; bounded steps/timeouts.That UHP detects or neutralises prompt injection.
Plugin stdio MCP servers stay inside the agent sandbox; only ${PLUGIN_ROOT} / ${PLUGIN_DATA} may expand in args/env/cwd; plugin root escapes are invalid; per-request plugin widening is forbidden; exported packages omit auth/headers.That package validity proves plugin safety, signature/trust-chain requirements, marketplace review, or any particular host scanner/admission policy.
TLS except loopback; HSTS advised; X-Frame-Options: DENY / frame-ancestors 'none'; erasure on session delete.Encryption-at-rest mandates, audit-log formats, or CORS policy specifics.

Read governance and versioning, conformance, architecture, Harness Plugins, the HTTP API map, the specification guide, UHP vs MCP, and the glossary.

The older individual draft links retained below identify prior revisions; current revision/status decisions above were rechecked on 4 October 2026.

The Security chapter is unchanged between 2026-10-04 and 2026-10-19 apart from its version header, and the Environments chapter is byte-identical across 2026-09-28 and 2026-10-19, so these two older revisions carry the same requirements.

The September sources below preserve the provenance of inherited requirements and dated implementation case studies.