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
cnfclaim 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.
| Document | Version and date | Intended status | What it defines |
|---|---|---|---|
| draft-ietf-wimse-arch | -08, 6 July 2026 | Informational | Terminology, trust domains, credentials, security context, provisioning, cross-domain and delegation scenarios, audit |
| draft-ietf-wimse-identifier | -04, 23 October 2026 | Standards Track | The URI workload identifier, the wimse scheme, comparison and validation rules |
| draft-ietf-wimse-workload-creds | -02, 2 July 2026 | WG document | The Workload Identity Token (WIT) and the Workload Identity Certificate profile |
| draft-ietf-wimse-wpt | -02, 27 August 2026 | WG document | The Workload Proof Token, a per-request proof of possession at the application layer |
| draft-ietf-wimse-http-signature | -08, 20 October 2026 | Proposed Standard | A profile of HTTP Message Signatures for workload-to-workload requests and responses |
| draft-ietf-wimse-mutual-tls | -03, 24 October 2026 | WG document | Workload authentication with mutual TLS and Workload Identity Certificates |
| draft-ietf-wimse-workload-identity-practices | -07, 22 September 2026 | Informational, 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
typwit+jwt, an asymmetricalg(noneprohibited), a requiredsubholding the workload identifier, a requiredexp, an optionaljtiand a requiredcnfclaim 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 aWorkload-Identity-TokenHTTP header, not the Authorization header. - Validation: trust anchors are bound to a trust domain and provisioned out of band. The
issclaim 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.
| Mechanism | Where proof happens | Strengths | Limits | Best fit |
|---|---|---|---|---|
| Mutual TLS with WICs (draft-ietf-wimse-mutual-tls) | TLS handshake, per connection | Mature tooling, meshes already do it, no application changes | Proof ends where TLS terminates: gateways and sidecars break end-to-end assurance | East-west traffic inside one mesh or cluster |
| WIT plus Workload Proof Token (draft-ietf-wimse-wpt) | Application layer, per request | Survives TLS termination; JWT based like the WIT; adapts to non-HTTP and event-driven systems | Replay caches are hard to share across validators; does not protect responses | Calls through gateways, proxies and across clusters |
| WIT plus HTTP Message Signatures (draft-ietf-wimse-http-signature) | Application layer, per request and optionally per response | Stronger integrity against middlebox changes; signed responses; flexible covered fields | Another technology layer and more implementation complexity; HTTP only | High-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
typwpt+jwt, signed with the key in the WIT'scnf. In version -02 it is sent in the Authorization header with aWPTscheme (replacing an earlier dedicated header). - Claims:
aud(the target URI without query or fragment), a required shortexp, ajtiof 128 bits of randomness, a requiredwthhash of the WIT, atthhash of any transaction token andothhashes 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
jtialready 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,@pathand@queryon requests and deliberately excludes@authoritybecause 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) andtag="wimse-workload-to-workload"are required; requests addwimse-aud. Thekeyidandalgparameters must not be used: the algorithm comes from the WIT. - A client can set
wimse-sign-responseto require a signed response, bound to its request throughwimse-req-nonce. Failed checks return HTTP 400 withwimse-signature-invalidwithout 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.
| Model | How it works | Main risk | Control |
|---|---|---|---|
| Direct provisioning | Credential configured when the workload is created | Long-lived credential baked into images or templates | Use only for bootstrap, with short validity and automated replacement |
| Bootstrap credential | A deployment-specific credential is exchanged for a WIMSE credential | The bootstrap credential becomes a static secret | One-time use, narrow scope, tied to a single instance |
| Attestation | Evidence about the platform or workload is verified before issuance | Weak selectors let any process on a node claim an identity | Combine node and workload attestation; review selector policy |
| Agent-assisted | A node agent attests local workloads and hands them credentials (SPIRE model) | Agent compromise exposes every workload on the node | Harden 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 pattern | WIMSE relationship | Gap to close |
|---|---|---|
| SPIFFE IDs, SVIDs and SPIRE | SPIFFE ID cited as a conforming identifier; X.509-SVIDs resemble WICs | JWT-SVIDs are bearer tokens; WIMSE WITs are key-bound and need a WPT or signature |
| Service mesh mTLS (sidecar) | Matches the mutual TLS profile | Proof stops at the sidecar; add application-layer proof for calls through gateways |
| Cloud workload identity and metadata endpoints | Described in the practices draft as today's delivery pattern | Provider tokens are bearer and provider-specific; federate rather than export keys |
| Kubernetes projected service account tokens | Platform-issued JWTs with custom audience and lifetime | Bearer; never reuse platform API tokens outside the platform |
| CI/CD OIDC tokens | Federation pattern; context claims must be validated | Over-broad subject matching; see the GitHub Actions OIDC Federation Hardening Guide |
| Static API keys between services | What WIMSE is designed to replace | No workload binding, no expiry; see the Dynamic Secrets and Ephemeral Credentials Guide |
Adopting WIMSE concepts: a phased approach
- 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.
- 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.
- 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.
- 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.
- Carry context explicitly. Replace forwarded user bearer tokens with exchanged, downscoped context tokens bound to the calling workload.
- Federate across domains. Replace cross-organisation shared keys with token exchange or identity chaining, one partner at a time.
- 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
subvalues not in the registered identifier list. - Repeated
jtior nonce values (replay attempts) and spikes in HTTP 400wimse-signature-invalidresponses. - 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
| Framework | Reference | How WIMSE concepts support it |
|---|---|---|
| NIST CSF 2.0 | PR.AA-01, PR.AA-03, PR.DS-02 | Managed workload identities and credentials, authenticated services, integrity of data in transit |
| NIST SP 800-53 Rev. 5 | IA-9, IA-5(2), SC-8, SC-23, SC-17, AU-2 | Service identification and authentication, public key-based authentication, transmission integrity, session authenticity, PKI certificates, event logging |
| ISO/IEC 27001:2022 Annex A | 5.16, 5.17, 8.5, 8.24 | Identity management, authentication information, secure authentication, use of cryptography |
| MITRE ATT&CK | T1528, T1550.001, T1552.005, T1557 | Key binding and short lifetimes blunt stolen application access tokens and their reuse, metadata endpoint theft and adversary-in-the-middle |
| OWASP NHI Top 10 | NHI4, NHI7 | Insecure 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
issURL 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
- IETF: Workload Identity in a Multi System Environment (WIMSE) Architecture (draft-ietf-wimse-arch)
- IETF: WIMSE Workload Identifier (draft-ietf-wimse-identifier)
- IETF: WIMSE Workload Credentials (draft-ietf-wimse-workload-creds)
- IETF: WIMSE Workload Proof Token (draft-ietf-wimse-wpt)
- IETF: WIMSE Workload-to-Workload Authentication with HTTP Signatures (draft-ietf-wimse-http-signature)
- IETF: Workload Authentication Using Mutual TLS (draft-ietf-wimse-mutual-tls)
- IETF: Workload Identity Practices (draft-ietf-wimse-workload-identity-practices)
- IETF: WIMSE Working Group Documents
Related NHI Mgmt Group resources: Cloud Workload Identity Guide · SPIFFE and SPIRE Guide · OAuth Transaction Tokens Guide · mTLS Guide · Workload Identity Federation Guide