Transcription
Howdy everyone. In this video, we are going to discuss advanced identity and access management strategies for AI agents and agentic systems. We will introduce a four-step system for maturing your environment to manage agentic AM and futureproof your AI systems.
So before we jump in, let's talk a little about what a four-step maturity model is based on. So maturity models really came out of the Capability Maturity Model in 1986. It was actually sponsored by the Department of Defense, and what they really wanted to look at are there levels of advancement you can do in a system from basically having nothing all the way up to very advanced systems. And this emerged in 1991 and has kind of become the standard that we base maturity models off of, and that's what we're going to actually use today.
Now, before we actually get to our maturity model and the four steps for maturing your AI and agentic systems, let's start with talking about the risk that we're really trying to address when we're using a maturity model. Now, when we start thinking about AI risks, and there have been a lot that have been talked about, we're really going to focus on some really main ones.
The first one is establishing accountability. And this really kind of stems out if you think about the way that applications are built today. There are teams that build applications, they use API keys to connect to whatever they need, or functional IDs, or system IDs, something that they use to connect their systems together, their processes. But it's really at the project level. It's really the project team that's doing that, and that's okay for our traditional systems. When we start talking about agentic and non-deterministic systems, you really want to change where the accountability lies. You really want to move that around the agents and the AI, and you want to have more controls over how they're connecting to the things. So, so your first risk is really how you establish accountability in your system.
The second one is the risk is around how do you enforce least privilege. And this starts talking about what we don't want are super agents. We don't want agents that have super agency that are allowed to do a lot of stuff. We really want them focused on a single task, and that's all they're allowed to do. And so what's the least amount of access and privilege they need to perform that task? So this is a risk as we get away from least privilege. You have agents that open up risk because they can do too much and access too many systems and provide a way for people to exploit that.
The next risk is then really kind of related, and it's how do you prevent abuse? And this can be either malicious, where somebody intentionally is building an agent that's going to go do something we we don't want it to do, or unintentional, where a developer builds something they're thinking they're doing a great AI use case, and it connects to something that they unintentionally introduce some sort of a a breach or access to things they shouldn't. So it could be very unintentional. What we really want to make sure is that we're preventing any kind of abuse of our agents in an agentic system.
And then the last big thing that we're really looking at as a risk is how do we safeguard data. And this again, if agents are querying data, they're getting access to data for whatever reason, it's it's they're bringing back information, or they're actually initiating processes. We want to make sure that the user, if they're representing a user in this case, that the user user actually can have access to that data, and also that the agent is allowed to have access to that data. We want to make sure that there are guardrails in place to prevent unauthorized access to data.
So these are really the the risks that we talk about when we're thinking about how are we going to have protect our agentic systems and what's a maturity model for doing that.
So let's let's start with the very lowest rung on the maturity model. And the bottom of this is really ad hoc. We will call this our maturity step is going to be step one. And ad hoc really says that you don't have much of anything, right? You're out there. You're building agents. You have pressure on you to to do things around AI. So you're building systems, but you're really not thinking about the risk. You're really not thinking about how is this system running? What is it running against? You're just trying to run your system in a very basic way. So let's we will call this step actually step one. All right.
Now now we want to get into step two. So and again, this is a maturity model, and we can really think of these as steps. So when we think about the next piece of this, this is really our foundation. The next level of maturity is our foundation, and that's the the the the the least amount of controls that we can put in place to make sure that our system is at least behaving in a way that we want. And so when we think about the foundation and we want to establish secure and auditable agent access, the first thing we want to do is assign non-human identities to agents. Make sure that there's at least something that can represent the agent and and the actions and the tasks that they're performing.
Once we have that in place, the next thing we really need to do at the foundational level is have basic delegation and on behalf of. In other words, what we want to do is make sure that whoever the user is at the very front of our agentic system that's prompting and trying to accomplish something, that we can delegate that to an agentic system, and the agent will work on behalf of that user. Now, that's for a system where the agents are actually representing people. But we also have autonomous systems where the agents are acting on their own, and even in those cases, we're delegating rights from one agent to another. We want to maintain this.
And then the last thing that we really want to do at our foundation level is have a SIM, our Security Information and Event Management. So we put a SIM in place so that we have auditability and compliance. So this basically says at this next step of maturity that we we understand who the agent is. We are delegating the rights along the flows, and we have some level of logging and tracking. So we have a bit of auditability and compliance here. All right.
So let's think about what then the next level of maturity looks like. So this is really our enhanced step in our maturity model and and and taking what we started off in the basic concepts and let's add a little bit to it. So very first thing that we want to do in the enhanced step is we really want to treat agents as first-class citizens. So in the second step of our foundational model, or in in our maturity model, we wanted to assign at least what we already have existing, right? Which is non-human identities. And and while that is useful to help us know who the agent is, when we get to the next level, the maturity model, we really want to start treating them as unique, their own things, much like we would humans and and and people inside of an identity governance system. So we want to treat them as first-class citizens.
And when we do that, we also want to make sure that they are ephemeral credentials that we assign them. In other words, we know who the agent is. We're treating them like a part of an organization to a certain extent, but when we give them credentials to do stuff, we want it to be ephemeral. It is only for that task that they're that the agent or the agentic system is trying to accomplish. Whereas, you know, in a human, you would have a persistent and and somewhat permanent identity and credentials that you can use. For this level of the maturity model, we want to start saying, okay, this agent, we will give you credentials just for the task that you're trying to perform.
The next thing that we want to do in this level of of the maturity model is have fine-grained and context-based access. In other words, when you know, one of the things when I was talking about establishing accountability in more of your traditional IT systems is we have these established API keys that last for a while, or maybe you you rotate them a little bit, but it always gives that application the access to what it needs to do. When we start thinking about agentic systems and the fact that they're non-deterministic, and the path and the task they're trying to accomplish can change every time, we want to make sure that when we know who the agent is, we treat it as a first-class citizen. That credential only lives for that task. And we only give the access that we need for that agent for that time to the specific thing that they're the agent is trying to accomplish.
And then the final thing that we want to do here is real-time detection. So we want to start watching, is something going wrong? Is can we detect an anomaly? Is something in the behavior of this flow and system not operating correctly? Now, remember, down here we started adding in logging and and some basic capabilities for compliance and auditability. Now we want to be able to do real-time detection in case something is going wrong and we can detect that. All right.
Now let's kind of go to the fourth step in our maturity model and the final step. And this is really about being adaptive because, as I mentioned, it's a very dynamic environment. It's it's it's changing every time you go through it because of the non-deterministic nature. So we need to always be adapting to that environment. And to do this, we need continuous authentication. We need to have risk-based reauthentication. And we also want to have real-time revocation.
And really, what this whole final step in the maturity model is about is as a flow is happening, all throughout that flow, each agent, we want them to be continually identifying themselves, authenticating that we know who they are. We want to always make sure that if if a flow is happening and there's levels of of sensitivity, like if we're trying to access really sensitive data, that it's risk-based, right? We know how much risk is involved in each step of an agentic flow, and therefore we can actually authenticate based on knowing what the risk is. And we don't want that to just be done for an agent and it's always available. We want each step to kind of look at what are we trying to accomplish, what's the context of that, and continually look at the authentication around that. And then, of course, if something happens, you know, if we have this real-time detection, we can build on that and have real-time revocation. So if we do detect that something is happening, then we can revoke that access and and stop and put some blocks in place.
And so you can kind of see all of these build on each other, right? You start with nothing. You put some basic foundation stuff in place. You have some enhancements and start getting better logging. You you you have controls over the credentials the agents are using. And then you start getting more adaptive and continually evaluating everything. And so each step the maturity model kind of adds a little bit more.
And by doing all this, if we go back to the to the risk now, we can establish accountability because we know who the agents are. We know when we establish the credential. We keep that very short-lived. We have tracking and auditing. We know everything going on. So we can really establish accountability. Where? Well, the enforcement of the least privilege. That's really when we get into these fine-grained contextual access. That's really agent can only do what the agent is allowed to do. When we start talking about preventing abuse, that's is when we start getting into the SIMs and the the error detection and we the real-time revocation of of credentials. That's how we can monitor for abuse, intentional or otherwise or unintentional, and be able to do something about it. And of course, having all this propagation of of identities and delegations and on behalf of and and the way that we identify our agents allows us to make sure that we're safeguarding our data in a proper way.
So, in summary, what we're really trying to do is not tell you to do everything at once. Here's everything you need, but really start with the basics. Start with your foundation and then start building up and improving your system by following this maturity model. Thank you.