Join our Newsletter — 33% off our NHI Course
Home› Guides› WIMSE Workload Identity Architecture Guide: Workload Credentials Across…
Guide Cloud & Workload Identity

WIMSE Workload Identity Architecture Guide: Workload Credentials Across Multi-System Environments

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 27 October 2026 17 min read
On this page

Service-to-service calls still run on bearer tokens, shared API keys and certificates that each platform issues in its own format, so a request that crosses a gateway, a mesh and a second cloud loses any proof of which workload actually made it. The IETF Workload Identity in Multi System Environments (WIMSE) working group is defining a common model for this problem: a trust domain, a URI workload identifier, key-bound workload credentials and three ways to prove possession of them on the wire. This guide explains the WIMSE architecture and its companion drafts as they stood on 27 October 2026, shows how they map to what you already run (SPIFFE, service meshes, cloud federation, OAuth token exchange) and gives a practical adoption path. For the broader picture of cloud workload identity, start with the Cloud Workload Identity Guide; this page goes deeper on the standards layer.

Key takeaways

  • WIMSE is still a set of Internet-Drafts. On 27 October 2026 none of the WIMSE documents was an RFC; only the Informational workload identity practices draft had reached the IESG, so design to the concepts and track the wire details.
  • The credential is key-bound, never a bearer token. The Workload Identity Token (WIT) carries a public key in its cnf claim and the drafts state it must not be used as a bearer token: every use needs a fresh proof of possession.
  • Three proof options cover different paths. Mutual TLS with a Workload Identity Certificate, a Workload Proof Token (WPT) per request, or HTTP Message Signatures (RFC 9421) with optional response signing.
  • Identity, context and authorisation are separate layers. A valid workload credential proves who is calling; the security context (often a transaction token) says on whose behalf and why; policy still decides what is allowed.
  • Most of the groundwork is available today. SPIFFE IDs already conform to the WIMSE identifier rules, and short-lived X.509 workload certificates, federation and token exchange can be deployed now and aligned with WIMSE as the drafts settle.

The WIMSE document set and its status

WIMSE is not one specification. The architecture draft defines vocabulary and building blocks, and separate drafts define the identifier, the credentials and the proof mechanisms. The earlier combined service-to-service protocol draft (draft-ietf-wimse-s2s-protocol) was replaced by draft-ietf-wimse-workload-creds, with the WPT, HTTP signature and mutual TLS parts moved into their own documents. Status below is taken from the IETF Datatracker WIMSE documents page, checked 27 October 2026.

DocumentVersion and dateIntended statusWhat it defines
draft-ietf-wimse-arch-08, 6 July 2026InformationalTerminology, trust domains, credentials, security context, provisioning, cross-domain and delegation scenarios, audit
draft-ietf-wimse-identifier-04, 23 October 2026Standards TrackThe URI workload identifier, the wimse scheme, comparison and validation rules
draft-ietf-wimse-workload-creds-02, 2 July 2026WG documentThe Workload Identity Token (WIT) and the Workload Identity Certificate profile
draft-ietf-wimse-wpt-02, 27 August 2026WG documentThe Workload Proof Token, a per-request proof of possession at the application layer
draft-ietf-wimse-http-signature-08, 20 October 2026Proposed StandardA profile of HTTP Message Signatures for workload-to-workload requests and responses
draft-ietf-wimse-mutual-tls-03, 24 October 2026WG documentWorkload authentication with mutual TLS and Workload Identity Certificates
draft-ietf-wimse-workload-identity-practices-07, 22 September 2026Informational, with the IESG (AD evaluation)How workloads get and use credentials today: platform JWTs, federation, cloud metadata, SPIFFE, CI/CD, meshes

The Datatracker page also lists about eighteen individual drafts filed against the group, many on AI agent delegation, attestation and cross-organisation chains. They are not working group documents and can change or expire quickly. For the agent-focused drafts, see the IETF Agent Identity and Authorisation Drafts Tracker.

Core building blocks of the architecture

Workloads, services and trust domains

  • Workload: a logical, independently addressable piece of software that may run as many workload instances. A service is the function or API that one or more workloads implement, and it can carry its own identity separate from any instance.
  • Trust domain: a logical grouping of systems that share security controls and policy. The architecture says it should be identified by a fully qualified domain name of the defining organisation, and it maps to one or more X.509 trust anchors plus a way to obtain a JWK Set for validating WITs. How that mapping is distributed securely is explicitly out of scope, which makes trust bundle distribution your design problem.
  • Identity proxy: an intermediary, such as a gateway or sidecar, that can inspect, replace or add to identity and context, for example by minting a transaction token.

The workload identifier

The identifier draft defines a URI that names a workload within a trust domain. Any absolute URI scheme may be used; spiffe and a new wimse scheme (wimse://<trust-domain>/<path>) are the examples. Rules that matter for implementers:

  • The authority (trust domain) is required, an FQDN is recommended, and IP addresses should be avoided except for legacy compatibility.
  • The path is required and non-empty; . and .. segments, query, fragment, user information and port are not allowed. Implementations must support identifiers up to 2,048 bytes.
  • Comparison is byte-for-byte after RFC 3986 syntax normalisation. Authorisation should use the whole URI, and wildcard or prefix matching should not be used unless policy explicitly allows it.
  • Paths can leak topology, so keep externally visible identifiers free of sensitive detail.

Workload credentials

  • Workload Identity Certificate (WIC): an X.509 certificate carrying exactly one URI subjectAltName with the workload identifier. Certificates with zero or several such URIs are rejected. DNS names are recommended as well where the certificate also serves TLS.
  • Workload Identity Token (WIT): a JWT with typ wit+jwt, an asymmetric alg (none prohibited), a required sub holding the workload identifier, a required exp, an optional jti and a required cnf claim containing the workload's public key as a JWK. ES256 must be supported by general-purpose implementations. The draft says WITs should be short-lived, on the order of hours, and travel in a Workload-Identity-Token HTTP header, not the Authorization header.
  • Validation: trust anchors are bound to a trust domain and provisioned out of band. The iss claim must not be used to fetch trust anchors from the token alone, which closes the classic "trust whatever issuer the token names" mistake.

Security context and attestation

The security context is the information a workload needs for authorisation, accounting and audit: who the end user is, what transaction this is, which hops it has passed. It may be a signed JWT such as an OAuth transaction token, and it can be bound to a workload identifier or a transaction. Attestation follows the IETF RATS architecture (RFC 9334) and is used at provisioning time, with SPIRE given as an example of agent-assisted attestation. See the OAuth Transaction Tokens Guide and the SPIFFE and SPIRE Guide.

Proving possession on the wire: mTLS, WPT and HTTP signatures

Holding a key-bound credential is not enough; the caller must prove it holds the private key for each connection or request. WIMSE offers three mechanisms, and the architecture also allows layering a transport credential to a proxy with an application-layer credential to the final destination. A destination must not assume the transport identity is the application caller unless policy or protocol establishes that relationship.

MechanismWhere proof happensStrengthsLimitsBest fit
Mutual TLS with WICs (draft-ietf-wimse-mutual-tls)TLS handshake, per connectionMature tooling, meshes already do it, no application changesProof ends where TLS terminates: gateways and sidecars break end-to-end assuranceEast-west traffic inside one mesh or cluster
WIT plus Workload Proof Token (draft-ietf-wimse-wpt)Application layer, per requestSurvives TLS termination; JWT based like the WIT; adapts to non-HTTP and event-driven systemsReplay caches are hard to share across validators; does not protect responsesCalls through gateways, proxies and across clusters
WIT plus HTTP Message Signatures (draft-ietf-wimse-http-signature)Application layer, per request and optionally per responseStronger integrity against middlebox changes; signed responses; flexible covered fieldsAnother technology layer and more implementation complexity; HTTP onlyHigh-value APIs where response integrity matters

Mutual TLS details

  • Relying parties hold a local mapping from trust domain to trust anchors and reject any chain that does not validate to the anchors for the trust domain in the peer's identifier. Path validation and revocation follow RFC 5280; CRL or OCSP is a deployment choice.
  • Servers should set the serverAuth extended key usage and clients clientAuth. When a client connects by DNS name it must still perform normal server identity checks (RFC 9525) even if the workload identifier is valid.
  • The draft itself recommends WPT or HTTP signatures in addition to TLS wherever end-to-end workload authentication is needed through intermediaries. See the mTLS Guide.

Workload Proof Token details

  • A WPT is a JWT with typ wpt+jwt, signed with the key in the WIT's cnf. In version -02 it is sent in the Authorization header with a WPT scheme (replacing an earlier dedicated header).
  • Claims: aud (the target URI without query or fragment), a required short exp, a jti of 128 bits of randomness, a required wth hash of the WIT, a tth hash of any transaction token and oth hashes of other tokens present. These hashes bind the proof to every token in the request.
  • Lifetimes must be short, on the order of minutes or seconds. Receivers should reject a jti already seen in the validity window, and raw WPTs must not be logged by default.

HTTP Message Signatures details

  • The WIMSE profile of RFC 9421 requires @method, @path and @query on requests and deliberately excludes @authority because proxies rewrite it. Content-Type, Content-Digest (RFC 9530, required with any body), Authorization, Txn-Token and Workload-Identity-Token must be signed when present.
  • Signature parameters created, expires (minutes), nonce (at least 64 bits, 96 recommended) and tag="wimse-workload-to-workload" are required; requests add wimse-aud. The keyid and alg parameters must not be used: the algorithm comes from the WIT.
  • A client can set wimse-sign-response to require a signed response, bound to its request through wimse-req-nonce. Failed checks return HTTP 400 with wimse-signature-invalid without revealing which check failed. See the Web Bot Auth and HTTP Message Signatures for Agents guide for the same RFC used by agents on the public web.

Provisioning credentials to workloads

The architecture names four provisioning models and three delivery channels. Your choice decides how much of the "secret zero" problem remains.

ModelHow it worksMain riskControl
Direct provisioningCredential configured when the workload is createdLong-lived credential baked into images or templatesUse only for bootstrap, with short validity and automated replacement
Bootstrap credentialA deployment-specific credential is exchanged for a WIMSE credentialThe bootstrap credential becomes a static secretOne-time use, narrow scope, tied to a single instance
AttestationEvidence about the platform or workload is verified before issuanceWeak selectors let any process on a node claim an identityCombine node and workload attestation; review selector policy
Agent-assistedA node agent attests local workloads and hands them credentials (SPIRE model)Agent compromise exposes every workload on the nodeHarden and monitor the agent; limit identities per node

For delivery, the practices draft rates environment variables as the weakest option and says they must not be used where the platform offers an alternative; prefer a local API (domain socket or metadata endpoint) or a memory-backed file mount written atomically, and block server-side request forgery to local credential endpoints. The 2024 cloud extortion campaign in which attackers scanned 230 million targets for exposed .env files and used the AWS keys they found shows what happens when long-lived keys are delivered as environment files.

Context, token exchange and cross-domain calls

  • Context scenario: a context service, often reached by token exchange, creates the security context; the gateway forwards it and downstream workloads include it on their calls. Bearer tokens from the external client are usually not forwarded inward.
  • Delegation and impersonation: a workload authenticates to a token service with its own identity and receives a delegation or impersonation token (OAuth 2.0 Token Exchange, RFC 8693). For asynchronous and batch jobs, the acting workload obtains downscoped credentials and appears as the actor in the actor chain, bound to its own credential. See the OAuth Token Exchange and Delegation Guide.
  • Cross-domain: a token service in the source trust domain exchanges internal identity and context for a token usable externally, and a token service in the target domain issues the access token, following the OAuth identity chaining draft.
  • AI and ML intermediaries: the architecture treats agents as delegated workloads, says autonomous actions not tied to a principal must be distinguishable (separate identities or scopes), and requires each hop in a multi-agent chain to scope and re-bind context explicitly.
  • Federation today: the practices draft favours the OAuth assertion pattern (RFC 7521, RFC 7523) for presenting a platform credential to an identity provider, and asks issuers to set an explicit JOSE typ, use a single audience, keep internal and federation credentials separate and validate context claims such as the Git branch rather than only checking they exist. See the Workload Identity Federation Guide.

Where WIMSE fits with what you run today

Existing patternWIMSE relationshipGap to close
SPIFFE IDs, SVIDs and SPIRESPIFFE ID cited as a conforming identifier; X.509-SVIDs resemble WICsJWT-SVIDs are bearer tokens; WIMSE WITs are key-bound and need a WPT or signature
Service mesh mTLS (sidecar)Matches the mutual TLS profileProof stops at the sidecar; add application-layer proof for calls through gateways
Cloud workload identity and metadata endpointsDescribed in the practices draft as today's delivery patternProvider tokens are bearer and provider-specific; federate rather than export keys
Kubernetes projected service account tokensPlatform-issued JWTs with custom audience and lifetimeBearer; never reuse platform API tokens outside the platform
CI/CD OIDC tokensFederation pattern; context claims must be validatedOver-broad subject matching; see the GitHub Actions OIDC Federation Hardening Guide
Static API keys between servicesWhat WIMSE is designed to replaceNo workload binding, no expiry; see the Dynamic Secrets and Ephemeral Credentials Guide

Adopting WIMSE concepts: a phased approach

  1. Inventory service-to-service credentials. List every static API key, shared secret, bearer token and certificate used between workloads, with owner, lifetime and which hops terminate TLS. This is your baseline metric.
  2. Define trust domains and an identifier scheme. Choose FQDN-based trust domains per environment or business unit, and a path convention (for example environment, namespace, service) that carries no sensitive detail.
  3. Issue short-lived, attested X.509 workload certificates. Deploy attestation-based issuance (SPIRE, mesh CA or cloud workload identity), one URI SAN per certificate, and automated rotation. Pilot on one non-critical namespace with mTLS in permissive mode, then strict.
  4. Close the TLS-termination gaps. For flows through gateways or across clusters, prototype WIT plus WPT or HTTP signatures behind a feature flag on one API pair. Because these drafts are still changing, isolate the implementation in a library you can update.
  5. Carry context explicitly. Replace forwarded user bearer tokens with exchanged, downscoped context tokens bound to the calling workload.
  6. Federate across domains. Replace cross-organisation shared keys with token exchange or identity chaining, one partner at a time.
  7. Roll back safely. Keep the previous authentication path enabled in parallel and switch by policy, not by redeploying; remove it only after logs show zero use for an agreed period.

Decision guidance: a small organisation on one cloud and one cluster will get most of the value from mesh mTLS plus cloud federation and need not touch WPT or HTTP signatures yet. Large organisations with multiple clusters, API gateways and partners are the target audience for application-layer proof, because that is where TLS-only identity breaks. Choose HTTP signatures over WPT when response integrity or middlebox tampering is a concern, and WPT when you need something that also works for message queues.

Detection and measurement

The architecture requires that every authenticated request leaves a verifiable trace whatever the authorisation outcome, recording timestamps, source and target identifiers, authentication method, decision, context claims and delegation metadata, while never logging bearer tokens, private keys or raw proofs. Forward these records to the SIEM and watch for:

  • Credentials presented from an unexpected node, cluster or trust domain, and WIT sub values not in the registered identifier list.
  • Repeated jti or nonce values (replay attempts) and spikes in HTTP 400 wimse-signature-invalid responses.
  • Certificates or WITs with lifetimes longer than policy, or issued outside the attestation path.

Metrics that show progress:

  • Percentage of service-to-service calls authenticated with a key-bound credential rather than a bearer token or static key.
  • Median and maximum workload credential lifetime.
  • Number of static inter-service secrets remaining, trending to zero.
  • Percentage of flows through intermediaries that carry application-layer proof.
  • Time to revoke and reissue all credentials in a trust domain.

For detection content specific to machine identities, see the Detection Engineering for Non-Human Identities Guide.

Framework mapping

FrameworkReferenceHow WIMSE concepts support it
NIST CSF 2.0PR.AA-01, PR.AA-03, PR.DS-02Managed workload identities and credentials, authenticated services, integrity of data in transit
NIST SP 800-53 Rev. 5IA-9, IA-5(2), SC-8, SC-23, SC-17, AU-2Service identification and authentication, public key-based authentication, transmission integrity, session authenticity, PKI certificates, event logging
ISO/IEC 27001:2022 Annex A5.16, 5.17, 8.5, 8.24Identity management, authentication information, secure authentication, use of cryptography
MITRE ATT&CKT1528, T1550.001, T1552.005, T1557Key binding and short lifetimes blunt stolen application access tokens and their reuse, metadata endpoint theft and adversary-in-the-middle
OWASP NHI Top 10NHI4, NHI7Insecure authentication and long-lived secrets between services. See the OWASP NHI Top 10 NHI4 Insecure Authentication Guide

Common failure patterns

  • Treating mesh mTLS as end-to-end identity: the sidecar or gateway terminates TLS, and the backend authorises the proxy, not the caller. The mutual TLS draft itself warns about this.
  • Prefix or wildcard identifier matching: policies such as "allow anything under spiffe://prod.example/ns/payments/" let a newly deployed or compromised workload inherit access. Match the full URI unless policy explicitly says otherwise.
  • Trusting the issuer named in the token: fetching keys from the iss URL in an unverified token lets an attacker supply their own issuer. Bind trust anchors to trust domains out of band.
  • Using JWT workload tokens as bearer tokens: a JWT-SVID or platform token copied from logs works anywhere until it expires. Bind tokens to keys and require proof per request where possible.
  • Logging proofs and tokens: raw WPTs, signatures and bearer tokens in debug logs turn the SIEM into a credential store. Hash or redact.
  • Building to a draft version and forgetting it: header names have already changed between WPT versions. Pin the version you implement and review on each new revision.

Practitioner checklist

  • Record the WIMSE draft versions you design against and set a quarterly review.
  • Define FQDN-based trust domains and an identifier path convention with no sensitive data.
  • Distribute trust anchors per trust domain out of band; never derive them from token contents.
  • Issue workload certificates with exactly one URI SAN, short lifetimes and automated rotation.
  • Deliver credentials through local APIs or memory-backed files, not environment variables, and block SSRF to local credential endpoints.
  • Identify every hop where TLS terminates and add application-layer proof (WPT or HTTP signatures) where the backend needs to know the real caller.
  • Replace forwarded user bearer tokens with downscoped, workload-bound context tokens.
  • Authorise on full identifier matches and validate context claims, not only their presence.
  • Log identity, method, decision and delegation metadata for every request, without secrets.
  • Track the share of key-bound service calls and the count of static inter-service secrets monthly.

Standards and references

Related NHI Mgmt Group resources: Cloud Workload Identity Guide · SPIFFE and SPIRE Guide · OAuth Transaction Tokens Guide · mTLS Guide · Workload Identity Federation Guide

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 27 October 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.