Identity Is A Belief: Workload Identity and Agents
Everyone is worried about what agentic workloads can do and how to grant them privileges they can’t abuse - whether it’s a coding agent running amok on your laptop, or an agentic workload stealing credentials and exploiting kernel bugs in your infrastructure. How can you give these workloads privileges to do useful work, but prevent them from leveraging or abusing those privileges to do things you don’t want them to do?
The worry is well-founded - the reality of identity and access in software systems was shaky long before agents arrived.
What’s “Workload Identity” in Software Systems?
Identity in software systems is a belief. When an entity presents some credential(s) that proves to our satisfaction that that entity is who it claims to be, we call our belief about that claim that entity’s identity. The more facts we have that support that belief, the more we trust it.
It doesn’t matter if that entity is a person (you, trying to read your emails) or an agentic workload (also trying to read your emails) - it works the same way. Identity must be established with credentials, and then privileges attached to that identity are granted.
A credential is any fact that helps establish that identity - a password, your favorite album, your grandmother’s birthdate, your mobile phone’s fingerprint sensor. The more credentials that can be provided, the more confident we can be about the identity of the entity we’re talking to that wants privileges to do something.
Virtually all software systems used everywhere in the world hang an awful lot of privileges on an identity, once it is sufficiently established by facts (credentials). Once your banking app has been convinced of your identity by the credentials you provide, it grants you a set of privileges - such as the ability to transfer every last dollar out of your account. The banking app believes you are who you say you are at that point, so granting you these privileges is considered safe.
How are identities granted privileges? In virtually all software systems, a simple list - commonly known as an access control list (ACL) - is maintained somewhere that says “this identity, once we have established it as a strong belief, gets these privileges”. Something or someone has to maintain that list, by:
- Adding identities to that list.
- Removing old/expired identities from that list.
- Adding or removing privileges assigned to those identities in the list.
That’s how you get access to your email, that’s how you get access to your financial accounts, that’s how your payroll system works, that’s how you are allowed to upload and view pictures of your own family.
It’s not just people that treat identity as a fact when it is really just a (hopefully well-supported) belief - software systems do as well. But there are some big systemic problems with this approach.
What’s Broken With Existing ACL-Based Identity?
What’s described above is a pretty intuitive model we all rely on every day, but it has a whole lot of nasty gotchas, common pitfalls, and exploitable systemic gaps.
- I can steal credentials, and present them to establish a mistaken identity, getting access to things I shouldn’t.
- I can forge credentials and do the same.
- I can exploit old/expired identities to get access I shouldn’t.
- I can use privileges assigned to an identity to “leapfrog” and grant myself new privileges that weren’t intended.
- I can use a valid identity to convince another entity with a different identity to do something I’m not allowed to do, on my behalf (the famous “confused deputy” problem which infects nearly every software system on the planet).
Every piece of software or website that you’ve ever used that establishes your identity has fallen victim to all of these attacks. They’re so common they’ve been treated as an inevitable cost of doing business by large swaths of the industry - until agentic workloads happened, anyway.
Why Agentic Workloads Make The Risk Many Times Worse
Agents exacerbate every problem that already exists with ACLs and the standard credential-identity-privilege pathway, because they run inside your infrastructure and systems, often need a large set of privileges to do what you want them to do, and are fully capable of rapidly and creatively exploiting sidechannels, stale credentials, and gaps in your identity flows. It’s an extreme version of the defensive asymmetry computing suffered under for decades before even agents were a thing.
Not only that, but agentic workloads are often short-lived and transient, which means securely automating properly-scoped credentials and ensuring those credentials don’t live longer than the agentic workload itself is something that most environments are simply not equipped to manage. And leftover, exfiltrated, or improperly-scoped credentials are at the root of many recent high-profile agent escapes.
Solving The Problem With Object Capabilities
At Edera, we deal directly with securing and isolating agentic and similar untrusted workloads, and we’re pretty confident that the best way to eliminate these issues in our own systems is by moving to a capability model of authorization, using object capabilities.
Object capabilities fix a lot of problems with the standard credential-identity-privilege model by essentially taking an axe to the first two parts. Capability models discard the need for agentic workloads to hold credentials and the need to establish an identity, leaving only privilege grants for us to worry about.
In an object capability system, entities are granted privileges directly. If an entity holds a reference to a specific object capability, it has the privilege to do something to that object. If it does not hold a reference to an object capability, it has zero privileges to it and does not even know it’s there. An entity may delegate access to the object references it holds, but never to things it does not.
When a system, such as an OS or a website, is presented with a request for a service it provides, it needs to decide if it should actually do what the requestor is asking for. The way it decides is what we’re talking about when we talk about access control. If you’re like most people, the first thing you’re likely to think of is to ask the requestor “who are you?” The fundamental insight of the capabilities paradigm is to recognize that this question is the first step on the road to perdition. - Chip Morningstar, 2017
Think of it this way - if you launch an agentic workload on your computer, running under your credentials, it can effectively access anything you can, and do anything you can do. If you ask it to update a sales document you have access to, you have to hope that it doesn’t upload your payroll info somewhere, or delete all the cat pictures on your hard drive.
With the ACL model, you either have to trust that it won’t take those privileges and do something you wouldn’t want, or you have to layer another, secondary ACL model on top of the one already in play, which is rarely sufficient and is difficult to maintain and manage.
We believe that neither of those approaches are good enough for the world we live in now.
What if instead the agentic workload did not inherit any permissions, hold any identity, or have any credentials, but was instead given an unforgeable read/write handle to the sales document, and that alone? Then it could do what it liked with the sales document, but couldn’t touch anything else. It couldn’t even see anything else. You don’t have to be concerned that it might touch something else, or that it might misunderstand what you wanted and break containment, or connect to the internet, or anything. It can only deal with the object capabilities it has been explicitly granted.
What’s more, this model has benefits even if your agentic workload doesn’t work like this.
It is critical that the isolation and containment system that surrounds your untrusted workload does work like this even if your untrusted workload does not - because even if the agentic workload compromises its containment system and its local kernel, it can never gain ambient privileges to anything outside of its security zone. It cannot gain privileges or access based on its identity or a remote ACL. It only has access to what it has been explicitly given.
Solving The Rest Of The Problem: Bridging Object Capabilities to Identity With SPIFFE
That sounds great, and it is, but there’s a remaining problem. The issue with using a capability-based privilege model is that virtually every other system in the world simply isn’t designed to work like that.
Even if Edera uses capability systems internally to ensure a strong security and isolation model for agentic workloads - which it does - it is inevitable that those agentic workloads will need to talk to external systems that know nothing of capabilities, and simply want a regular old identity for that agent that they can use to map to a regular old ACL for privilege grants.
The best security model in the world stops right where the software implementing that model ends, and there’s no way around that.
That’s where Edera’s SPIFFE-based workload identity model comes in - it’s the bridge between the better world (capability-based privileged models) and the world we have now that is poorly-fitted to agentic workloads (identity and credentialing-based models).
Edera’s SPIFFE-based workload identity model credentials workloads via hypervisor-backed attestations - that is, facts that can be proven about the state of the workload from outside of the workload, that do not require us to trust that the workload isn’t lying to us.
We build a belief about the workload’s identity based on the large number of facts (credentials) about the workload we can reliably attest. Edera, as a secure hypervisor control plane, can collect a lot of facts that are difficult-to-impossible to forge, so we can establish that belief about an agentic workload much more strongly than your banking app typically can about you.
Once workloads have been credentialed - or attested - enough to establish their identity, we give each workload that wants one its own transient, automatically rotated cryptographic identity document in the SPIFFE Verifiable Identity Document (SVID) format - you can think of this as an X.509 certificate.
At this point the workload can use this SVID to authenticate itself to non-capability-aware remote systems that require identities. This identity document cannot be forged, dies with the workload, and cannot be used outside of the zone that it is granted in, even if it is exfiltrated, even if a workload is compromised or malicious.
SPIFFE SVIDs and Zone Attestation in Practice
These SVID grants happen internally through Edera’s capability-based privilege model. A workload may request and manage its own identity by talking to the SPIRE WorkloadAPI socket directly itself, or Edera can mint one on-behalf-of the workload and mount it into the workloads filesystem as a plain X.509 cert, so that the workload itself doesn’t need to be directly SPIRE-aware to obtain this identity.
The nice thing about SPIFFE/SPIRE attestations is that they’re composable and stackable. This means that, for example, an agentic workload can run in an Edera zone, and can be supplied with a transient, autorotated cryptographic SVID it can use to authenticate itself with external systems, only-if-and-while the following facts can be proven to be true by something outside the workload’s reachable context:
- That workload is proven to be running in the correct isolated context (zone)
- That the zone has not been compromised or tainted in any fashion.
- That zone is running the exact number and kind of OCI containers specified.
- All of the OCI containers running in that context are sigstore-signed by a trusted authority.
- etc
The identities obtained in this way can never be valid outside of the isolated context, and a workload from one zone, no matter what, can never impersonate or access a workload from another zone. If the workload lies, it doesn’t matter. If it’s compromised, it doesn’t matter. If it leverages kernel exploits to escape its OCI boundaries, it doesn’t matter. If it runs as root, it doesn’t matter. That’s the power of combining hypervisor isolation with external attestation.
You can do this in Kubernetes too, using standard SPIRE deployment mechanisms. You can even integrate Edera’s workload identity feature with your existing SPIRE server deployment, if you wish. Or utilize this for a subset of Edera-protected workloads on mixed-use nodes.
Pulling Workload Identity and Object Capabilities Together
At Edera we strongly believe that the future of agentic security is object capability systems, and our core isolation product is internally built around that. But we also know that object capabilities are not something every other piece of software in the world can or will adopt anytime soon, so building a secure, built-in form of workload identity on top of our object capability system to bridge the gap from the capability world to the standard world of credential-identity-privilege pathways is something we had to do.
Get in touch, and try it out in Kubernetes - agentic security is a solvable problem.

-3.avif)