Latest / Identity at the Center / #422 - Decoded - Securing AI Agents with Standards You Already Have

Transcript

#422 - Decoded - Securing AI Agents with Standards You Already Have · Identity at the Center

• 0:04
  Breaking down the IAM standards that shape how identity works.
• 0:09
  This is decoded by identity at the center.
• 0:15
  So welcome to Decoded by Identity at the Center.
• 0:18
  My name is Jeff Steadman. You may know me from Identity at
• 0:21
  the Center podcast. This is a new thing that we're
• 0:24
  doing here on the channel to get more deep into the standards.
• 0:28
  I'm joined by my friend and Co host Sean.
• 0:30
  Hello, Sean. How's it going, Jeff?
• 0:34
  Sounds weird not hearing. I'm not hearing your other like
• 0:38
  how are you doing? Good.
• 0:39
  How are you good? So I'm low.
• 0:41
  A little bit of a non standard intro, you know, This Is Us
• 0:44
  trying to figure it out, right? And building the good ship
• 0:47
  Decoded as we're sailing it down the high seas.
• 0:50
  What is this podcast for, Sean? I know we're doing it under, you
• 0:54
  know, decoded by a day in the center, but what does that mean
• 0:57
  in the real world? So in in travelling identiverse,
• 1:01
  authenticate in different conferences, everyone's always
• 1:03
  asked like we want the next layer, not like the layer that
• 1:07
  you have to read like an archives white paper, but like,
• 1:11
  how do you make it practical and pragmatic?
• 1:13
  And I think that's the the middle piece of linking
• 1:16
  together, like what your what you put out in your in your
• 1:19
  podcast center, But then like, how do you start linking it
• 1:22
  together? Because I'm a super proponent on
• 1:25
  standards will set you free down standard centers give you an
• 1:28
  interoperability. I think this is that that niche
• 1:31
  to say, let's connect the dots. Let's start chaining things
• 1:36
  together. How and how it how it answers a
• 1:38
  lot of deeply technical questions.
• 1:43
  But to bring it up the level of like understanding because we
• 1:46
  can get into the we can go into the an hour on one topic, but
• 1:51
  this is meant meant to give you both depth and breath at at the
• 1:55
  same time. So we're going to focus quite a
• 1:57
  bit on standards. I kind of see this as a little
• 1:59
  bit of a spiritual successor to Victoria Bertocchi's Identity
• 2:03
  Unlocked, who unfortunately he passed away a couple years ago,
• 2:06
  but you know, he had a great podcast.
• 2:07
  Go back and listen to those. But the, the idea here is to
• 2:11
  kind of dig deeper into those standards.
• 2:13
  Now, I am not an identity standards person.
• 2:15
  I don't write them. I read them, you know, I watch
• 2:18
  them and and I look for them from integration standpoint.
• 2:21
  But the whole reason you're here, Sean, is to help with that
• 2:24
  as well as our guest Peter to like talk through.
• 2:26
  OK, what does this mean in the real world?
• 2:28
  So the idea is kind of set the stage.
• 2:29
  OK, why is this important? What is it we're focusing on
• 2:32
  today? How do we do it?
• 2:35
  Like, that's how I really want to kind of get out of this
• 2:37
  conversation because you're going to be educating me just as
• 2:39
  much as everyone else who's listening that maybe, you know,
• 2:41
  isn't a standards expert is. OK.
• 2:43
  So what is this thing? What does it do?
• 2:46
  How do I use it? How do I make this real in the
• 2:49
  real world? That's kind of what I'm hoping
• 2:50
  to get out of it. Does that make sense, John?
• 2:52
  100%. OK, the the very brief answers,
• 2:55
  I appreciate that. No.
• 2:58
  It's brilliant. It's very well put together.
• 3:00
  I mean, it's let's let's dive. I'm ready to go in SO.
• 3:02
  What are we going to talk about today?
• 3:04
  We're going to talk about a gentic identity and and mixture
• 3:12
  about dedication authorization and like the whole stack of like
• 3:16
  identic identity, identic auth, identic authorization.
• 3:20
  We're going to get into like control planes with gateways and
• 3:24
  maybe even how we get into continuous evaluation.
• 3:27
  Not to Cape, there will be Cape in here, but I'll be continuous
• 3:31
  evaluation. So you can get to like that
• 3:32
  whole the the buzzwordy continuous governance loop and
• 3:36
  then assurance. But Peter and I are going to
• 3:38
  help break it down into actual practical terms or it isn't
• 3:42
  going to be like on market texture slide or you know, it'll
• 3:45
  be real. And there's standards out there
• 3:47
  to support that. So we've got things like Spiffy
• 3:49
  and Olaf and shared signals framework.
• 3:50
  You mentioned Cape, right, risk and whimsy and a whole bunch of
• 3:54
  like other alphabet soup that we're using.
• 3:57
  But let's go. Ahead and use our It's almost
• 3:59
  there. Build the whole bingo cart
• 4:00
  right? Yeah, I would say do a drink
• 4:02
  every time you hear an acronym, but anybody and I am would tell
• 4:04
  you like, yeah, you're going to be, you're not going to make it
• 4:06
  like 5 minutes without being completely off the off the rails
• 4:09
  if that's the case. But yeah, it's there's a lot to
• 4:13
  cover here. So let me introduce Peter
• 4:15
  Castleman. He is the VP of open standards
• 4:18
  at de facto. Welcome to the first ever
• 4:20
  decoded, Peter. Well, Jeff, thank you.
• 4:23
  It's great to be here, and what an honor to be the 1st guest for
• 4:27
  this new podcast. So maybe a little bit about
• 4:30
  myself, VP of Open Standards at de Facto chair of the Whimsy
• 4:35
  working group, one of the the alphabet soups, also frequent
• 4:38
  contributor, regular contributor to Oauth and long time identity
• 4:44
  enthusiast. And so I think identity has
• 4:47
  really come to the fore over the last sort of five years.
• 4:50
  And certainly I think what we're seeing right now in terms of the
• 4:54
  sort of genetic side of things, really shining a light on the
• 4:58
  space. And, you know, and we've been
• 5:00
  working on standards to help secure identity and making
• 5:06
  identity interoperable for a long, long time.
• 5:10
  And really talking a little bit about today how you can actually
• 5:12
  benefit from all the standards work that's been going on for
• 5:16
  more than a decade and how that's really ready for use.
• 5:20
  Yes, there's gaps, but I think the the thing that I really want
• 5:24
  to talk about today is you can get really, really far with the
• 5:27
  systems you already have and for the standard that's already in
• 5:30
  place. And that's really kind of the
• 5:32
  focus for today, for me at least.
• 5:34
  You don't. We don't need to wait for things
• 5:36
  to be embedded or anything else. It's like an assembly problem.
• 5:39
  Let's just, it's putting things together and let's go honestly.
• 5:43
  Yeah. And and it's all about just
• 5:45
  taking, having the right framing, right and the right
• 5:47
  framework through which to look at this.
• 5:49
  And we, you know, I think when we get into it, we'll talk more
• 5:52
  about it. But I think there's some really
• 5:53
  interesting, like when you start looking at this and you look at
• 5:58
  this whole AI space and you just remember that you're dealing
• 6:02
  with a piece of software that's running somewhere somewhat non
• 6:05
  deterministic. We'll talk about authorization.
• 6:08
  You can get a long, long way, right?
• 6:11
  Agents are workloads. And once you understand or
• 6:14
  appreciate that you all of these tools that we've been building
• 6:18
  for a decade or more suddenly becomes very applicable.
• 6:21
  So let me ask a quick question here.
• 6:22
  We we're, we're talking about AI agents and authentication
• 6:26
  authorization. But in my mind, this isn't a new
• 6:29
  thing. Like we've had non human sort of
• 6:32
  identities for a long time, right?
• 6:34
  Service accounts, all kinds of stuff have been around forever.
• 6:37
  What is it, you know, why is it important that we start to get
• 6:40
  this going now? Like where do we, you know, what
• 6:43
  is it that's like, hey, you know, OK, is it just the scale?
• 6:46
  Is it the speed? Is it, you know, what is it
• 6:48
  that's like, wow, we better get our handle on this like now
• 6:51
  compared to five years ago or 10 years ago?
• 6:54
  Yeah, I mean, what an excellent question, right.
• 6:55
  I, I think when I went from talking to practitioners like
• 6:59
  Sean and and others in the industry, right.
• 7:01
  My observation is this first of all, the scale is going to be
• 7:06
  very, very different from what we're used to.
• 7:09
  And a lot of non human, when people talk about non human
• 7:11
  identity and they talk about things like service accounts,
• 7:13
  etcetera, what they really did is they borrowed human identity
• 7:17
  concepts and they just sort of manually, you know, it's all a
• 7:20
  manual workaround to make it work for these non human actors
• 7:24
  that that is no longer a scalable problem or or scalable
• 7:28
  approach, right? That's just not working anymore.
• 7:30
  So the scale, the other thing that's really becoming clear why
• 7:34
  we need standards in this space particularly is cross-platform
• 7:38
  Peter's law of agentic utility. The more cloud services, the
• 7:43
  more platforms an agent can access, the more useful that
• 7:46
  agent becomes. And the agents are expensive.
• 7:48
  And so you want them to be as as useful as possible.
• 7:52
  And that means you need to have an identity infrastructure or
• 7:55
  identity capability to connect everything to your agent and for
• 7:59
  your agent to connect to everything and do that securely.
• 8:02
  And this is what standards kind of enable for you.
• 8:04
  So I think that's sort of the whole multi we used to talk
• 8:07
  about multi cloud, really multi platform, right, because the the
• 8:11
  other thing is, right, the cloud vendors will talk to you about
• 8:13
  the cloud, but they'll never talk to you about your on Prem
• 8:16
  environment and everybody still has significant on Prem, right?
• 8:21
  And those things need to be connected and and this is
• 8:23
  critical for getting value out of your eugenic investments.
• 8:28
  I think the other thing that's happened is the threat landscape
• 8:31
  has significantly changed, right?
• 8:33
  I think when you look at how like we've been spoiled for up
• 8:38
  until like with a very benign geopolitical environment with,
• 8:44
  you know, things have been bad, but they're about to get a lot
• 8:47
  worse, right? I think I'm thinking about how
• 8:49
  you harden your infrastructure and making sure that your agent
• 8:54
  that you know, which agent you're running, that that agent
• 8:56
  is running in a correct environment, that it is acting
• 9:00
  the way it should and making sure that you have some form of
• 9:03
  authorization and control over what that agent and your other
• 9:06
  non human actors can do. I think that's another
• 9:09
  absolutely sort of critical thing.
• 9:12
  And then, you know, I think the the last two things that I
• 9:14
  always sort of think about really the I think one of the
• 9:19
  challenges that we we see, right, with existing
• 9:22
  infrastructures, it was really, it was really not optimized for
• 9:27
  these environments, right? It was really not built for
• 9:31
  automation. And the absence of automation,
• 9:35
  having humans interact with these things, make these systems
• 9:38
  incredibly brittle. One of the things that I think
• 9:40
  frequently gets forgotten by security and identity
• 9:43
  practitioners, the security practitioners availability,
• 9:47
  remember the old CIA confidentiality, integrity
• 9:50
  availability, availability as part of security.
• 9:54
  And if you're not automating, your risk of outages goes way,
• 9:58
  way up, right? Especially when it comes to
• 10:00
  things like credentialing, identity proofing and so on.
• 10:04
  And so I think the, the, I think a lot of these problems, Jeff,
• 10:08
  to your point of we've recognized it for a long time,
• 10:11
  but I think we finally like it's now become really under like
• 10:18
  the, the, the wolf is at the door, right?
• 10:20
  We either make this leap or we get overwhelmed with managing
• 10:25
  service accounts by hand and manually rotating secrets
• 10:28
  forever. Right?
• 10:29
  Like that is a that's a terrible future for all of us.
• 10:32
  Not nobody should have that end of life.
• 10:34
  And everybody does a really good job of it today.
• 10:36
  So I'm sure nothing bad can can happen when all of a sudden like
• 10:39
  it exponentially grows over because you're trying to manage
• 10:41
  right? Yeah.
• 10:43
  I mean, I I think have you know and that's and I think the
• 10:47
  industry is responding in in a good way, right.
• 10:49
  But you're right. And, and I think, you know, I,
• 10:52
  I'll, I'll, I'll go out like API keys is sort of the, you know,
• 10:56
  one of the first things that we really need to get rid of in
• 10:59
  this new eugenic world. And the cost of not doing so,
• 11:03
  you'll have, you have no way to control where that key goes.
• 11:07
  Once a developer or an engineer or a system has control over it,
• 11:12
  it'll show up in all sorts of ways.
• 11:13
  And these days, right when I steal an API key, I'm not just
• 11:16
  stealing access. I'm, I'm, I'm stealing
• 11:19
  permission to use your budget and I can exhaust your LLM
• 11:23
  budget very quickly, right? And so these things are, they're
• 11:27
  sort of, and there's real financial implications now,
• 11:29
  right? It's not just a, a thing about,
• 11:31
  oh, I'm going to get a fine or I'm losing customer trust or any
• 11:34
  of those things. It's like, you know, there's a
• 11:36
  bottom line, right When you do that.
• 11:39
  And I think the other thing about API keys that that then
• 11:43
  happens, of course, is when you want to go and say, oh, I had a
• 11:46
  problem or I have to rotate that key or I am provoking that key,
• 11:51
  you're going to cause outages and an outage.
• 11:53
  Like if you're a large Fortune 10, Fortune 500 company, your
• 12:00
  service go down for an hour, like that's millions, 10s of
• 12:04
  millions, maybe more, right? It's a lot of money that that's
• 12:07
  at risk. And so I think like that's kind
• 12:10
  of almost step one. But and that's just the, that's
• 12:13
  just on the authentication side of things, right?
• 12:16
  But you asked about what changed.
• 12:19
  I think it's this new environment, speed, multi cloud,
• 12:22
  new lack, you know, new security threat environment really.
• 12:28
  Yeah, I think you, I think you get a lot of stuff I had I was
• 12:30
  going to layer onto here, but I the, the way to look at it from
• 12:34
  engineering standpoint is this is distributed system design on
• 12:37
  steroids. It's really, it's insane because
• 12:41
  you have to you have to have to factor in financial business.
• 12:45
  So if you're an SRE system reliability engineer, this is
• 12:49
  right up your alley. But again, the multi cloud keys,
• 12:52
  the interop, the federation, if you will, it's so important
• 12:56
  because most, most big companies are not going to say I'm all in
• 12:59
  on X platform because there is a shift that I think I'm at least
• 13:03
  I'm seeing is a lot of sensitive things are being moved off of
• 13:08
  cloud service providers and on to like their own data centers
• 13:11
  using their own models. And how do you cross talk?
• 13:14
  The answer's not going to be. Here's my API key.
• 13:17
  Here's your API key. That can't be it, to Peter's
• 13:19
  point. It can't be no.
• 13:21
  Please let that not be the case, right?
• 13:23
  But I think that is a good natural segue into one of the
• 13:28
  first, first big topics of the deep dive is agentic identity
• 13:33
  and identifiers, Right, Jeff? Yes, absolutely.
• 13:37
  What does that mean? What is an identic identity
• 13:41
  identifier? Well, let's let's take a step
• 13:43
  back first, right. I think when we we think about
• 13:46
  agentic, you know, I think one of the interesting things that
• 13:51
  I've realized is we have all these standards and we have
• 13:53
  standards about or around identifiers, right, for non
• 13:58
  human entities, etcetera. But one of the things that like
• 14:04
  Sean and I have been talking and others have been talking over
• 14:07
  the last couple of months is, you know, one of the challenges
• 14:10
  is really creating a mental model for people about how do
• 14:13
  all of these things fit together.
• 14:15
  And so I think the first one is OK, right?
• 14:18
  You must have an identifier. If you don't have an identifier,
• 14:21
  there's no way you can reason over any access that this thing
• 14:25
  has to have, right? There's no way you can really do
• 14:27
  any authentication. And so when I, we, so the first
• 14:31
  thing that I think in any sort of agentic or AI identity
• 14:37
  management system that you're going to need is you need to be
• 14:41
  very clear about what your identifier is, right?
• 14:44
  And then once you have an identifier, we'll get into
• 14:47
  details of each of these. But once you have an identifier,
• 14:50
  what you really need to think about is, OK, how am I going to
• 14:53
  present that identifier? And this is where you get into
• 14:56
  the credential discussion. You're going to need an X5O9
• 14:59
  cert, You're going to need a jot, You're going to need a
• 15:01
  workload identity token, right? But you need some way to
• 15:05
  cryptographically bind that token in.
• 15:07
  Sean, you've got your hand up. I do not, so I will lower it.
• 15:11
  Oh, hold on, hold on. OK.
• 15:14
  And so you have this credential, right?
• 15:16
  The next thing is of course like, OK, I now have a standard
• 15:19
  for my identifiers. I can, I know how I'm going to
• 15:22
  present it. How do I decide, right?
• 15:26
  How do I decide what identifier to assign to what workload,
• 15:30
  right? And this is where you get into
• 15:33
  this is think of it as identity proofing of the workload, right?
• 15:37
  There's a workload running. What is the attestation process,
• 15:40
  right? How do I figure out that that
• 15:42
  workload is running in the right environment?
• 15:46
  It has the right bill of materials.
• 15:48
  It has the right, is running on the right hardware.
• 15:54
  And then based on all of that information, I decide, OK, I'm
• 15:57
  going to give it an identifier, right?
• 15:59
  I'm going to assign an identifier encapsulated
• 16:02
  credential so that at the station slash identity proofing
• 16:05
  step is sort of the next thing that your system needs to be
• 16:08
  capable of. And once you have that right,
• 16:14
  you also have to figure out like, how do I get that
• 16:18
  identifier and credential to my workload?
• 16:21
  Because the workload doesn't wake up and know it's identifier
• 16:23
  and credentials, right? It's going to wake up and it
• 16:25
  goes like, oh, who am I, right? And basically there's
• 16:30
  attestation process happens and then you go back and you say,
• 16:33
  OK, this is who you are, but you need to deal with that last mile
• 16:36
  provisioning. And that actually needs to be
• 16:38
  highly, highly robust. Now I'll talk more.
• 16:40
  We'll talk more about spiffy and how spiffy like systems really
• 16:44
  enable that. And now you're at a very
• 16:49
  interesting point. Right now you have a workload
• 16:51
  with credentials. You've got some trust in that
• 16:54
  set of credentials. Now that workload can
• 16:57
  authenticate. So now this workload can call or
• 17:00
  that agent, right? Can call this other agent and
• 17:03
  say, Hey, this is my identifier. And the other agent can now do
• 17:10
  an amazing thing. It can make an authorization
• 17:12
  decision, right? Or there's an authorization
• 17:15
  layer that makes the decision for the the agent, right?
• 17:18
  So you, you go from identifier all the way through to
• 17:22
  authentication and now you can make authorization decisions.
• 17:26
  But of course, right. And I think a lot of today
• 17:28
  authorization is very, you know, typically very static.
• 17:33
  And I think one of things we really have to assume now is
• 17:36
  that your authorization is not static, it's dynamic, right?
• 17:39
  And I think Sean, you've talked a lot about this concept of
• 17:41
  dynamic authorization, right? This idea that your
• 17:44
  authorization state changes on you all the time.
• 17:47
  And this is where you sort of doing somewhere in your, your
• 17:50
  next layer in your architecture has to be about, OK, I can
• 17:54
  authenticate, I can authorize, right?
• 17:56
  It's different ways to do that. But now how do I collect all
• 18:00
  these signals? And then when the identity
• 18:03
  threat assessment changes, how do I feed that back?
• 18:07
  How do I change the authorization state, right?
• 18:10
  How do I even go as far back to say, stop issuing this
• 18:13
  credential because these workloads have been compromised,
• 18:17
  right? And I think that's a very
• 18:19
  important part of closing that loop is this dynamic identity
• 18:22
  concept. And then of course, on both
• 18:24
  sides of that, there is, you know, for each one of those
• 18:27
  things, you're going to have a set of rules.
• 18:29
  This is my rules for identity authentication authorization.
• 18:32
  And on the other set is compliance, right?
• 18:35
  You're going to measure against your policies, right?
• 18:38
  And this is kind of a way to think about your, this is a
• 18:42
  framework, right, with which you can sort of look at a genetic
• 18:45
  identity. And the key insight here is
• 18:49
  right, if you would start filling out, OK, so which
• 18:51
  standards do I use for these things?
• 18:54
  The key insight is workloads, agents are workloads.
• 18:58
  And now you can use all the workload identity and workload
• 19:01
  and traditional standards that's already capable of dealing with
• 19:05
  non human entities. You can now actually start
• 19:08
  filling out that that that architecture.
• 19:13
  So, so that's kind of how I'd say a framing for this.
• 19:16
  And, and this is actually exactly the thing that we wrote
• 19:19
  up in what people now refer to as the AIMS draft.
• 19:24
  I think officially it's called the AI Agent authentication and
• 19:28
  authorization draft. And it really introduces this
• 19:31
  concept of an AI management system.
• 19:34
  And then all it does is describes how do you map every
• 19:37
  standard that is relevant to this framework so that you don't
• 19:42
  have to go and invent everything new and can just use the things
• 19:44
  that's basically off the shelf and available.
• 19:48
  And I'll have a link in our show notes for people to check that
• 19:50
  out. I I prefer aims.
• 19:52
  That's easier for me to pronounce than AI Agent
• 19:54
  authentication and Authorization framework.
• 19:56
  I, I, I think we may have to change the name of the draft.
• 20:00
  Who knows, right? But I I've certainly seen people
• 20:02
  refer to it as the AIMS draft frequently.
• 20:06
  So, Sean, what Peter's describing sounds an awful lot
• 20:09
  about the plumbing that works behind this idea of continuous
• 20:13
  identity. Is that accurate?
• 20:16
  Accurate so continuously identity was was a pretty much a
• 20:18
  foundation to get the human stuff ready so that when the
• 20:21
  agents or the but the bots come ready for it.
• 20:24
  But it is in principle it's zero trust at every layer.
• 20:28
  It's ephemeral verifiable work workload bound identities at
• 20:32
  every hop. You have to have it at almost
• 20:34
  every hop and it's it's just doing the human like I am things
• 20:38
  at scale. But maybe he related to it and I
• 20:42
  won't I won't. We should rehash it now we have
• 20:44
  enough to cover as as is, but the security and business
• 20:49
  implications here are immense. They're immense.
• 20:52
  Yeah. This is the goal, right?
• 20:56
  We we've been talking about things like 0 standing privilege
• 20:58
  and zero trust for any forever it seems like, but it's probably
• 21:03
  only been like four or five years in in the real world.
• 21:05
  But this is how it gets done. So let's dig deeper into how
• 21:10
  that works. So Peter, you kind of alluded to
• 21:13
  things like Spiffy Spire, shared signals, and, you know, other
• 21:16
  sort of open standards, right? And I love the idea of trying to
• 21:19
  get this right now because we're sort of at that beginning part
• 21:23
  of it. But let's start with, well,
• 21:25
  where should we start? Is it the identifier layer?
• 21:28
  Do we get into things like whimsy, or do we want to start
• 21:31
  somewhere else? Yeah, let's build that way,
• 21:33
  right? I think it makes the most sense
• 21:34
  and it sort of gets us, gets us through this whole stack.
• 21:38
  And so in the draft and by the way, I should add like this
• 21:41
  draft as like we, we're sort of, I think we're out, we've got
• 21:46
  about, we've a total of 6 authors right now.
• 21:49
  So we've got folks like Brian Campbell from Ping and Aaron
• 21:52
  Porecki from ACTA, Jeff Lombardo from AWS, Yaroslav from a Shaku
• 21:57
  from Zscaler and also Nick Steele from Open AI, right.
• 22:03
  So we think we've like that's a, that's a fairly good
• 22:07
  representation across the industry working on this draft.
• 22:12
  And Sean of course, has been contributing and giving us all
• 22:16
  sorts of really good pointers and tips and writing the
• 22:18
  occasional PR even. So thanks for that, Sean.
• 22:23
  The but yeah, let's start with let's start with identifiers,
• 22:28
  right. So I think when it comes to
• 22:30
  identifiers in the Whimsy is the workload identity for multi
• 22:36
  service environments working group in the IATF and it was
• 22:44
  specifically charter to focus on this workload identity space.
• 22:49
  One of the things that Whimsy defines is it defines A Whimsy
• 22:53
  identifier. We've actually broken it out
• 22:55
  into its own spec. Whimsy also sets and defines a
• 23:00
  set of modern authentication mechanisms, which we'll talk
• 23:02
  about a little bit more later on, but it really provides this
• 23:06
  kind of framing. Whimsy is also very
• 23:10
  specifically, we are very mindful in the Whimsy working
• 23:15
  group to make it compatible with Spiffy.
• 23:18
  So Spiffy is a Cloud native Compute Foundation project.
• 23:22
  It stands for the Secure Production Identity Framework
• 23:25
  for everyone. And Whimsy is really an
• 23:29
  encapsulation of Spiffy. And so in Spiffy there is
• 23:34
  something called a Spiffy identifier, which is a Uri, and
• 23:38
  it is the Spiffy standard is very opinionated about what
• 23:43
  makes the Spiffy identifier. Whimsy is taking a slightly
• 23:48
  broader view and says, well, there are spiffy identifiers,
• 23:51
  but there's also other kinds of identifiers, right?
• 23:55
  And so Whimsy sort of provides the slightly broader set of
• 23:59
  definitions. And Whimsy really defines the
• 24:01
  identifier as any Uri which can then be profiled.
• 24:05
  And So what that means is every spiffy identifier is also a
• 24:09
  whimsy identifier. And so that's one of the ways in
• 24:12
  which we sort of keep these systems compatible.
• 24:14
  Jeff, you've got your hand up. Yeah, so I hear this term quite
• 24:17
  a bit when we talk about, you know, interactions.
• 24:20
  Is the word opinionated? So when you say something is
• 24:23
  opinionated for the people who aren't following along, like I
• 24:26
  have opinions, does that count? Like when you say opinionated in
• 24:29
  the standard like what does that mean?
• 24:31
  Opinionated in the standard means there are very specific
• 24:34
  rules that a group of people argued over for many, many
• 24:39
  months and finally agreed that this is the opinion that they
• 24:43
  all agree on. And this is how something
• 24:47
  typically is constrained, right? This is how we're going to
• 24:49
  constrain identifiers for this kind of deployment.
• 24:54
  So that's what we mean by opinionated.
• 24:57
  You're of course everybody is welcome to have additional
• 25:00
  opinions, but the one in the document is the one that you're
• 25:03
  going to have to deal with. So we drive consensus through
• 25:06
  that. I love that.
• 25:07
  So yeah, please carry on. And so these two things end up
• 25:11
  being compatible in this way. So I think I'll talk more about
• 25:14
  Spiffy identifiers for a moment because they have been very
• 25:17
  broadly deployed, right? I think Spiffy has a system or
• 25:20
  Spiffy implementations. There are some of these
• 25:24
  deployments out there. They are issuing a billion
• 25:28
  credentials a day, right? These are things that operate at
• 25:33
  enormous scale. And so the Spiffy identifier
• 25:35
  itself, it's a Uri, it's hierarchical, it contains things
• 25:40
  like a trust domain. So credentials issued within the
• 25:44
  trust domain is encoded in this Uri.
• 25:47
  And then in in the path section, you can have sort of additional
• 25:51
  rules and use that for namespace management and things like that.
• 25:57
  Different deployments. Again, some deployments are
• 26:00
  opinionated about how they like to use or how they want to
• 26:07
  format their identifiers, but by and large, you actually have
• 26:11
  quite a bit of flexibility in that, right?
• 26:13
  And it gives enterprises a lot of control.
• 26:17
  And so that's just the identifier side of things.
• 26:21
  Moving on from identifiers, right?
• 26:24
  These identifiers then gets encapsulated in credentials and
• 26:30
  spiffy defines using a JWTJS and web token, which is a very
• 26:37
  common kind of authentication mechanism.
• 26:39
  It's a bearer mechanism. It is way better than any static
• 26:44
  API key because it's at least short lived.
• 26:46
  It's scoped, it can only presented be presented to a
• 26:50
  certain audience and so on, right.
• 26:52
  So it, it actually, it's like if you, it's, it is a huge step up
• 26:57
  from API keys, even though it's a bearer token.
• 27:00
  Then beyond that, right, the other credential type is X509
• 27:03
  certs, which makes sense. Like you want your workloads to
• 27:07
  be able to do mutual TLS, right? And authenticate that way and do
• 27:10
  that at the, at the transport layer, at the, the networking
• 27:14
  layer. JWTS are more often used at the
• 27:18
  application layer. And then one of the new things
• 27:21
  that Whimsy is actually introducing in this credential
• 27:24
  space is the so-called workload identity token.
• 27:28
  Think of it as an X5O9 cert in Jason format, right?
• 27:36
  So basically you now have not only a set of claims about the
• 27:41
  the identity of the workload, but you also have a key that's
• 27:45
  associated with that workload. And now your workload or your
• 27:48
  agent can actually use that at the application layer to sign
• 27:52
  transactions and to create things like Http://signatures or
• 27:57
  whimsy proof tokens. I'll talk more about that when
• 27:59
  we get to the authentication layer.
• 28:01
  But essentially these are sort of some of the new credential
• 28:04
  types or you know two of them widely deployed workload
• 28:08
  identity tokens about to drop off the production line already
• 28:13
  being adopted by Spiffy. And we expect that to just sort
• 28:17
  of find it's like that's going to progress over the course of
• 28:21
  the next couple of months. By the end of the year,
• 28:23
  hopefully from a whimsy perspective, saying this
• 28:26
  optimistically as Whimsy chair, I hope to see significant
• 28:30
  progress and that specs moving to completion.
• 28:36
  I feel like kind of to give kudos to all the acronyms here
• 28:39
  because we've got whimsy. Spiffy Spire, we've got a new
• 28:44
  one. I'm hearing maybe workloaded any
• 28:46
  token we can call that one wit I mean these are these are way
• 28:48
  better acronyms than like the normal like IGA and you know,
• 28:52
  Pam and things like that. I think it's the difference
• 28:55
  between engineers naming things and analysts naming things.
• 28:58
  Maybe that's fair. Could, could, could be, could
• 29:04
  be. So, so anyway, so, so this is
• 29:09
  kind of things that's happening at the standards.
• 29:10
  And so far you would see like you would have seen that we've
• 29:13
  not had to invent anything new, right?
• 29:15
  And so if you go back to our first premise, which is agents
• 29:18
  or workloads, it's like, well, give your agent a spiffy
• 29:22
  identifier or a whimsy identifier and then make sure
• 29:26
  that it has one of these credentials, right?
• 29:30
  And typically, right when people say, oh, but which credential
• 29:33
  should I give it? This is sort of to an earlier
• 29:37
  point in this conversation, right?
• 29:39
  Provision it with the credentials that your existing
• 29:41
  system knows how to handle, right?
• 29:44
  So there's no point in giving X509 certs to your agent if none
• 29:49
  of the protocols or none of the systems that your agent is
• 29:52
  interacting with is capable of dealing with MTLS, right?
• 29:57
  If your agents need to interact with O auth servers, give it an
• 30:03
  X 509 cert, give it a job, right?
• 30:07
  Your authentication server knows how to deal with those as
• 30:10
  authentication credentials. And so I would sort of encourage
• 30:14
  folks to think about right when you have to decide which
• 30:17
  credential type, this is all about compatibility and
• 30:20
  interoperability. However you're protecting your
• 30:23
  existing system, this is how you deliver.
• 30:26
  Make sure you deliver those credentials to your system.
• 30:30
  Hey, Peter, I think you said something that's really
• 30:32
  important. Connecting stiffy to Oauth is
• 30:36
  very, very important. Now it's it's Uber important.
• 30:41
  It's, I'm really glad you're bringing that up.
• 30:43
  And there's another spec that we have introduced in Oauth that I
• 30:47
  will also, we'll share a link for that as well.
• 30:52
  But it's basically Spiffy authentication with Oauth and it
• 30:59
  it's things that you could always have done, but we're now
• 31:02
  making it very explicit and the back.
• 31:05
  And again, tying this back into the agentic side of things, it
• 31:09
  also defines how you use client ID metadata, the CIMD spec with
• 31:15
  Spiffy so that you can dynamically register and you
• 31:20
  don't have to pre register with every O auth server.
• 31:24
  We're getting a little bit ahead of things because really the,
• 31:27
  you know, when we get to authorization, we'll get into
• 31:28
  that even more. But really like the setting the
• 31:31
  stage around you need these credentials to be connected and
• 31:36
  then they become really important when you hit the
• 31:38
  authorization layer, right? Like that's where, that's
• 31:42
  because that's where you need these credentials to be
• 31:44
  authenticating with. The next thing up is the
• 31:49
  provisioning side. So this is actually something
• 31:51
  that Spiffy does really, really, really well.
• 31:56
  Spiffy provides this. So one of the things that Spiffy
• 32:00
  does that is different from traditional human identity
• 32:02
  systems is it issues short lived credentials, right?
• 32:07
  And the, the, the key insight is that for humans or human
• 32:12
  identity systems, identity proofing is traditionally very
• 32:17
  expensive, right? When you show up at a company
• 32:20
  for the first time, people will spend a lot of money to ensure
• 32:25
  your identity. They will go and create an
• 32:27
  account and they'll give you a password and they say, Jeff,
• 32:31
  Sean, do not lose this thing, right?
• 32:36
  And so that is an account plus shared secret.
• 32:38
  And then of course, it turns out that that's bad advice or, but
• 32:43
  it doesn't work like that because, you know, the next day
• 32:45
  you arrive at the train station and somebody is trading
• 32:48
  chocolate bars for passwords. And guess what?
• 32:51
  Like that chocolate bar is very attractive, right?
• 32:54
  And so, and, and so, and then we had to invent MFA, right?
• 32:58
  This is where the whole MFA thing comes from.
• 33:00
  Because the thing that we give you, you're, you're going to
• 33:04
  lose control over that, right? Same as with API keys.
• 33:08
  What Spiffy's insight was, it's like actually one of the
• 33:11
  interesting insights about Spiffy is the cost of identity
• 33:15
  proofing for a non human actor or workload or an agent.
• 33:21
  It's very low, very cheap. You can do that every time this
• 33:26
  thing runs, right? Every time I show up at my
• 33:29
  corporate office, I know people can't do an identity proofing on
• 33:32
  me. Like that's going to be you
• 33:34
  can't run the background check and check my bill of materials.
• 33:37
  That's not like too expensive, but for your workload you can
• 33:40
  and for your agent you can. And so because of that right now
• 33:44
  it means you don't have to create these long lived service
• 33:48
  accounts and you don't have to provide long lived secrets that
• 33:53
  you hope your agent is not going to lose or the developer
• 33:57
  developing the agent is not going to lose, right.
• 34:00
  So what Spiffy does is it says we will automatic this
• 34:03
  attestation identity proofing step.
• 34:06
  We will establish the identity, we will provision the
• 34:09
  credentials and you don't need to have any secrets, right.
• 34:13
  And that's kind of part of this automation and deployment trick
• 34:17
  that that makes Spiffy very, very, very compelling.
• 34:21
  And that's how you know, that's the, that's how you get to
• 34:24
  provisioning and running a billion credentials per day is
• 34:28
  it's all automated right through this process.
• 34:32
  The other thing that it does on the provisioning side that you
• 34:34
  need to think about is when you're, you're issuing these
• 34:37
  short lived threads, one of the beautiful things is when you're
• 34:41
  doing, let's say you're issuing a new credential to a workload
• 34:44
  every 5 minutes, you're not going to do that with a human,
• 34:48
  right? You have to automate it.
• 34:50
  And so basically when you go down this path, you are always
• 34:53
  automating and there's no humans in the loop for any of this.
• 34:58
  And as a result, you also don't have these outages.
• 35:02
  So many practitioners that I folks that we talked to, they
• 35:07
  will tell you that the biggest problem with deploying some of
• 35:13
  these human identity systems for non humans is the outages,
• 35:20
  right? And, and so again, availability
• 35:22
  is a big part of it and Spiffy has this concept of renewing and
• 35:26
  keeping your credentials up to date all the time, Sean.
• 35:29
  Yeah, I think, I think you hit on something pretty important
• 35:31
  here. Practitioners that I've talked
• 35:36
  to at various companies, I rather said, yeah, I had to
• 35:40
  bundle in service accounts into my workload or service accounts
• 35:43
  plural. And it moves us backwards from
• 35:46
  the end goal because then to your point, beer, it's like,
• 35:49
  well, I got to rotate that password and it's like, oh, you
• 35:51
  just killed 15 agents doing 15 things.
• 35:55
  This answers that problem. And it actually from a business
• 35:58
  context, it reduces a lot of all the accounts for all that we
• 36:01
  see. Cause a lot of companies look at
• 36:03
  it as as, oh, I have to share credentials now with my agent to
• 36:07
  get my work load, to get my work done.
• 36:09
  The answer is, sure, you can do that.
• 36:13
  That's bad. Or you can do this fifty thing
• 36:17
  like it, it actually works. It does.
• 36:20
  And it's very once you see it in action, it is very like eye
• 36:24
  opening and the applicability just runs through your head
• 36:27
  like, oh, I can do this now and not now.
• 36:29
  And it's just it it it's it's very foundational to the entire
• 36:32
  chain of a gentic control. It's very, very, very
• 36:36
  foundation. I that's a fantastic
• 36:40
  observation, right? And I, I think just think about
• 36:45
  how it changes even how you think about governance, right?
• 36:48
  You no longer have these service accounts standing around.
• 36:52
  You no longer have these secrets you have to manage.
• 36:54
  It is, it really is sort of this it, it, you know, it's a real
• 36:59
  example of what happens when you really rethink and understand
• 37:03
  the problem you're solving versus just trying to Band-Aid
• 37:05
  or the thing with whatever you have, right?
• 37:09
  And so, so I think that's sort of the next thing Jeff is really
• 37:12
  thinking about that provisioning cycle.
• 37:13
  And I, I think if I had guidance for folks around that, right,
• 37:16
  Spiffy actually provides these mechanisms, let's call them
• 37:20
  runtime provisioning, right capability, keeping your
• 37:23
  credentials up to date, etcetera.
• 37:26
  I'd say whatever you're doing in that space, be very thoughtful,
• 37:29
  think about keeping this credentials short lived, right?
• 37:34
  Leverage the fact that you can dynamically attest to their the,
• 37:38
  the provenance. Think about how you can tie that
• 37:41
  back into your vulnerability life cycle management, right?
• 37:45
  Because one of the things that when you're running and you're
• 37:47
  doing that identity proofing bit, guess what, right, You're
• 37:51
  tying back to your bill of materials, right?
• 37:53
  So suddenly you can start looking and say, Oh, well, I
• 37:56
  have a vulnerability workloads that are using this library, not
• 38:00
  getting identities until we patch them, right?
• 38:02
  They have to be on the right version before they can go
• 38:04
  right. There's things like that that
• 38:05
  you can start thinking through or, or it gives you power and
• 38:08
  control, right to Sean's earlier point, right, You want a control
• 38:11
  system for your eugenic environment, these kinds of
• 38:14
  things enable it. Let.
• 38:17
  Me ask that question here here because it it it kind of goes on
• 38:20
  to provisioning. You mentioned like what happens
• 38:22
  if you know someone loses you know this you know what I guess
• 38:27
  what is the path for an agentic identity that has been provided
• 38:31
  this identifier? How do you can you lose it?
• 38:35
  How do you tie them together? And I'm curious you you
• 38:38
  mentioned this whole identity verification, right.
• 38:40
  I think you're referring to and maybe you were going to get this
• 38:42
  is the spiffy verifiable identity document or the SDID or
• 38:46
  SDID. Can I have multiple of those?
• 38:50
  Like is this just another thing that needs to be correlated back
• 38:53
  to sort of a a accountable identity somewhere or am I?
• 38:58
  Am I still thinking in human terms and this needs to be a a
• 39:01
  different layer of abstraction? No, no, Every so in the system,
• 39:07
  every, every actor, every agent, every workload has its own
• 39:13
  unique identifier and it has its own unique credential, right?
• 39:18
  And you can have multiple, you can have a next I have an
• 39:21
  answer. You can have a job.
• 39:23
  You can have an X 509 or sorry, whimsy identity or workload
• 39:28
  identity token. You can have multiple jobs,
• 39:31
  right? Because you're going to be
• 39:32
  accessing multiple workloads. So if you may, I am 1 workload,
• 39:38
  but I need a credential to access or to authenticate to GCP
• 39:45
  as one example. And then I need another.
• 39:47
  And it's audience, right? Your job has an audience, but
• 39:50
  then I need to access something in Anthropic and so I need a
• 39:55
  different audience. So I have a separate one for
• 39:57
  that. And so you end up with a sort of
• 39:59
  set of, but it's always the same identifier.
• 40:03
  And so I can now you can correlate, right?
• 40:05
  Think about that. You're now when you think about
• 40:08
  governance, say, oh, I have this one agent.
• 40:13
  It has this identifier. It accessed all these systems
• 40:17
  and the way I know is because I can look at the identifier and
• 40:20
  the credential and all these systems that have got
• 40:22
  identified. And isn't it weird that there is
• 40:25
  like, why is it trying to access this other system, right?
• 40:29
  Because even just like, oh, access failed, it's like, oh, I
• 40:32
  know who tried to access that because you can look at the
• 40:35
  identifier, right? And so you can have multiple of
• 40:38
  these things, Sean, OK. You're going, you're going
• 40:40
  exactly where where I think, I think organically the
• 40:42
  conversation shifting next is this is no different than a
• 40:46
  human being. When I log into my laptop in the
• 40:49
  morning, I go access application AI get a token, application BI,
• 40:54
  get a token. It's the same concept.
• 40:55
  It's just the scale. But you said something that your
• 40:59
  Providence and your your traceability is huge.
• 41:03
  And this is where like most companies are certain that throw
• 41:06
  out the, the lovely buzzword agentic gateways come into play
• 41:09
  here. I think where you're going with
• 41:12
  this pier is very, very prominent right now because you
• 41:17
  almost have to know pre intent, pre tool call or pre or post
• 41:23
  intent, depending upon the use case.
• 41:25
  But pre tool call to know, should you even let the agent go
• 41:30
  where it needs to go based on its scope and purpose?
• 41:35
  And that's where you're, you're getting into the, into the next
• 41:37
  part of the, the lovely fun conversation.
• 41:40
  Yeah, authentication, authorization, right.
• 41:45
  So, you know, I think let's quickly just talk about
• 41:49
  authentication, the beauty about having these credentials.
• 41:53
  As Sean pointed out, it's like you can now, yeah, you can
• 41:58
  authenticate to all these different systems, but
• 42:00
  authentication is not authorization, or at least
• 42:03
  usually it's not. And if you treat it that way,
• 42:06
  you're probably going to have some nasty surprises, right?
• 42:08
  So you do want this extra layer. The beautiful thing about having
• 42:13
  unique identifiers that can with which you can authenticate is
• 42:19
  you get this traceability, but you can have authorisation logic
• 42:22
  that is specific to to that identity or to that identifier.
• 42:29
  And I think one of the other things that's interesting is you
• 42:32
  can now have agents act as themselves or act on behalf of a
• 42:40
  user rather than an agent impersonating a user, right?
• 42:45
  And so I think those are really important distinctions.
• 42:48
  The thing that Sean talked about earlier, right, where people
• 42:51
  say, oh, I've got an agent, I'm going to give it my credentials,
• 42:55
  that's impersonation. And that is in my view quite a
• 43:00
  dangerous pattern. It's also an understandable
• 43:02
  pattern, but it's quite a dangerous pattern.
• 43:05
  A pattern that I think works better is delegation, right?
• 43:08
  I as the user have an identity and that identifier, the agent
• 43:13
  has an identifier, I am going to delegate to the agent and now
• 43:19
  the agent can act on my behalf. And that's sort of, and the good
• 43:25
  news again, right? People say, oh, that's going to
• 43:28
  be terrible. No, no, it turns out this is
• 43:30
  what O Auth has actually is, right?
• 43:33
  I think a lot of folks think about the O Auth protocol as,
• 43:37
  oh, it's an authorization thing, but in reality, it's an
• 43:40
  authorization delegation protocol.
• 43:43
  And when you look at it, what you do with O Auth is you as the
• 43:46
  user of the web browser delegates authority to the
• 43:51
  browser to act on your behalf and call APIs, right?
• 43:55
  So back to our earlier insight, workloads, agents are workloads,
• 44:00
  right? A browser is a workload.
• 44:03
  You can use the same protocol, you can use the same constructs
• 44:06
  and O auth, even when you look at, just like the job based
• 44:10
  access token, it already makes provision, right?
• 44:13
  It has this concept of a client ID which represents the piece of
• 44:18
  software making a call and it has the concept of a subject,
• 44:22
  the user that delegated to the client right now, one of the the
• 44:27
  challenges of course, is that when people implement it O auth
• 44:31
  and deployed it, they never wrote any authorization logic to
• 44:35
  reason over the client ID, right.
• 44:37
  And so that, and so I think there's a discussion that needs
• 44:41
  to happen around that, right? That, that is something.
• 44:43
  But you know, there are ways to, there are ways to deal with that
• 44:47
  through gateways and various other things.
• 44:49
  But that the, the core premise of delegation, authorization
• 44:53
  delegation is what O Auth has been doing for the last 15
• 44:57
  years, right? I think that is, and of course,
• 45:00
  the O auth ecosystem is huge. And so if you're in the space
• 45:05
  and you're thinking about a genetic identity, there's,
• 45:07
  there's a couple of in the, this draft that we talked about
• 45:10
  actually outlines this as well. There's a couple of O off specs
• 45:16
  That's really important, right? There is, of course, the
• 45:19
  authorization code flow that is that really should be the
• 45:23
  default that you use for users authenticating, for agents
• 45:29
  acting on their own things like RFC 7523, the job authorization
• 45:35
  grant flow, right? Those are really, really
• 45:38
  critical and also gets you a little bit out of some of the
• 45:42
  registration challenges and then some of the new specs, emerging
• 45:47
  client ID metadata. I think it's really important
• 45:50
  for dynamic registration. And so that's another one that I
• 45:54
  would say you definitely want to know about.
• 45:56
  The third one or a fourth one is the on behalf of people talk
• 46:00
  about on behalf of. What they really mean is I need
• 46:03
  proof that this user and this agent, this user delegated to
• 46:08
  this agent. Now that's either an access
• 46:10
  token or the other pattern that you can use here is you say,
• 46:14
  well, I'm going to do an on behalf of or a token exchange,
• 46:18
  right? And so there you use Oauth token
• 46:20
  exchange and say, here is the I have this token.
• 46:23
  Give me back another token that has these additional information
• 46:30
  about who the subject and the workload is, right?
• 46:33
  So that's sort of the fourth one that you really want to know
• 46:36
  about. Then there's two others that I'm
• 46:39
  going to quickly talk about that is they're about to be
• 46:42
  finalized. I'm co-author for both of them.
• 46:47
  So I'm, I really want to see them done.
• 46:49
  Now. The first one is transaction
• 46:51
  tokens. And so one of the things that
• 46:54
  we've observed, and this is again, a, it's kind of an anti
• 46:59
  pattern in the until sort of the 20/20/2023 period where when
• 47:07
  people get an access token, that access token is typically, it's
• 47:11
  called audienced for a specific resource server.
• 47:15
  But what then happens is that access token gets forwarded
• 47:19
  throughout the system so that all the downstream services can
• 47:23
  know who the user was, what scopes they had and you know
• 47:27
  what, who, what did they delegate, right.
• 47:31
  The problem with that is you're wide open to a thing called
• 47:33
  token theft. And so this is what Solar winds
• 47:37
  and various other sort of, you know, headline events have been
• 47:41
  about was threat actors figuring out that if I steal the token,
• 47:45
  doesn't matter how you authenticate, I have your token
• 47:49
  and now I can do anything. And of course, the more places
• 47:52
  in your system these access tokens are, the more places they
• 47:55
  can be exfiltrated from. And, and that, that has been
• 48:00
  like tokens have been a huge headache, right?
• 48:03
  And so one of the things that we've introduced as a result of
• 48:06
  this is this concept of transaction tokens.
• 48:08
  And so transaction token says, when you receive an access
• 48:12
  token, don't give it to someone else.
• 48:15
  Take that access token, go to your transaction token server,
• 48:18
  which may also be your IDP, and basically request a transaction
• 48:23
  token that ties all the information in that access token
• 48:28
  specifically to an individual transaction so that it cannot be
• 48:32
  used outside of that transaction.
• 48:34
  Time limited downscope it and augment it with additional
• 48:38
  authorization information, IP addresses, time of day,
• 48:43
  transaction limits, things like that.
• 48:46
  All the information that you're downstream systems will need.
• 48:51
  But now at least when that transaction token, as it travels
• 48:53
  through your system, somebody steals that token, they can't re
• 48:59
  enter at the front door. They can't even replay it in the
• 49:02
  transaction, right? Because this thing is tied for a
• 49:06
  specific to a specific transaction, right?
• 49:08
  So you don't have this, your risks around token theft is
• 49:11
  drastically reduced, right? And certainly you can't use it
• 49:15
  with a different transaction, right?
• 49:17
  You can't go and change and say, oh, this was $100 transaction.
• 49:20
  I'm going to turn it into $1000 transaction.
• 49:23
  Can't do it. It's a cryptographically
• 49:24
  protected token. So transaction tokens is is is
• 49:28
  is another one the the the other specification that I want, Sean.
• 49:34
  Yeah, it's you're hitting on like like I love transaction
• 49:38
  tokens and I think they'll, I think I would, I want to
• 49:41
  everyone listening to this or watching this, both mediums.
• 49:44
  I hope Jeff tying together transaction tokens with the
• 49:49
  whole chain is important. And here's why they give it as
• 49:52
  access tokens on the outside of the gateway, transaction tokens
• 49:57
  inside the gateway. You're like, what the hell?
• 49:59
  What does that mean? It means that any, any, any
• 50:01
  service call you're going to make is bound to context and
• 50:05
  reason. Peter, you said time.
• 50:07
  I'm all for that. But if you, if you're looking at
• 50:10
  this mature and Greenfield, maybe even little brownfield,
• 50:14
  the gateway's going to have every request and response the
• 50:17
  agent makes. So when the response comes back,
• 50:19
  you can just kill the transaction token and make it
• 50:21
  moot at that point. So it is so important here.
• 50:25
  And why, why is this the most probably the best piece of it is
• 50:31
  every service in the Paul chain gives you who who initiated it
• 50:36
  and or what, what agents calling it?
• 50:38
  What is it constrained to? And you're you're not even doing
• 50:42
  least privilege anymore. You're doing 0.
• 50:44
  And why does it matter? It's just governance thing,
• 50:46
  right? It's the you get a fully baked
• 50:51
  in audit trail for the agentic era in in the transaction token
• 50:56
  itself. It was very hard to not use the
• 50:58
  acronym Mr. Campbell told me never to use again.
• 51:01
  So I'm going to say transaction tokens around my life, but I
• 51:04
  just want to point it out that it's so pivotal, so pivotal to
• 51:07
  get that right. And it's like, well, there's
• 51:09
  this, there's this new tech, it's this, this new way to talk.
• 51:12
  Transaction tokens are a form of jobs.
• 51:13
  So again, not recreating the wheel, just staring at the wheel
• 51:18
  saying look, it's a wheel over here and it's a wheel over here.
• 51:22
  Absolutely, yeah. And I, I think, you know, I
• 51:25
  think one of the things that is very interesting about
• 51:27
  transaction tokens, of course is like the rate of we've seen so
• 51:31
  many adoptions of it already, right.
• 51:32
  It's actually, uh, I'd say, I'd say adoption is outstripping the
• 51:36
  ability of the spec to get finished at this point.
• 51:39
  We're seeing more adoption than, uh, getting the spec finished at
• 51:42
  this point, but spec will be finished.
• 51:44
  We're working on it. It's a very high priority
• 51:46
  because we're also beginning to see specific profiles of the
• 51:50
  transaction token spec for agentic use cases, right, where
• 51:54
  again other folks practitioners are Jeff used the the the
• 52:01
  earlier word, they're becoming more opinionated about how a
• 52:04
  transaction token should be used and then agentic deployment,
• 52:08
  right. And I think that's actually
• 52:11
  incredibly helpful, having practitioners come back and say,
• 52:14
  well, this is how we use it. This is what we've seen.
• 52:19
  Two more things on the old side for folks to look out for.
• 52:22
  Identity training and cross domain authorization is a key
• 52:26
  spec. It's being profiled.
• 52:30
  So Aaron Parecki and I think Carl McGuinness and Brian
• 52:33
  Campbell are profiling that spec right now for what they call
• 52:37
  cross app access. And that's a key specification
• 52:40
  in the agentic space as well, right?
• 52:43
  And it really allows you to have the user authenticate once or
• 52:49
  have the agent authenticate once, but then having the sort
• 52:52
  of cross app access so that the user doesn't have to go and
• 52:57
  authenticate to each individual servers and, and grant
• 52:59
  authorisation to each individual service.
• 53:03
  Uh, it's also actually really critical for the transaction
• 53:05
  token side of things. And so that's sort of a thing
• 53:08
  that we're, we Sean, and I've been talking about as well is,
• 53:11
  umm, OK, if you try your, you have a transaction token and you
• 53:16
  need cross domain access. How does that work?
• 53:18
  Right. And transaction tokens are meant
• 53:20
  to be used within a domain. And the trick is if you want to
• 53:23
  go cross domain, you use the identity chaining spec, right?
• 53:26
  That's the, that's the glue that allows you to access services in
• 53:30
  other in or resources in other domains.
• 53:34
  If you have a transaction token and you don't have an access
• 53:37
  token, and for that other domain, the the final one that
• 53:41
  I'm going to talk about, which I think is really going to do a
• 53:48
  ton, not just for a gentic, but just for everybody that has a
• 53:52
  client, a client ID and a client secret deployed is the O auth,
• 53:56
  the specific authentication for O auth draft.
• 53:59
  And again, I'll share a link to that, but that specification is
• 54:04
  really writing down things you can already do to a large
• 54:07
  extent, but really being very explicit, right?
• 54:10
  Again, being opinionated about how this would work so that
• 54:14
  there we have better interop. And that is really gonna allow
• 54:19
  you to use your, those specific credentials that you've
• 54:22
  provisioned, right, to replace client, client secrets at the
• 54:28
  very least. And you can use it with CIMD if
• 54:31
  you still need traditional client IDs.
• 54:36
  So that is on the O Auth side. And I think let's talk.
• 54:40
  And so I think the other thing I would say about the O Auth
• 54:43
  ecosystem, it is wildly rich. There's over 100 specifications
• 54:48
  in that ecosystem. What we did in this draft, the
• 54:52
  Ames draft is really to say, here are the ones that you
• 54:55
  really, really should care about.
• 54:58
  I mean, the O Auth ecosystem is rough for people who spend all
• 55:02
  their time in it. If you're a newcomer to O Auth,
• 55:06
  you'd kind of need the, like here's the CHEAT SHEET, right?
• 55:09
  Here's the, here's the guidebook for, for how to navigate that.
• 55:13
  But of course, as I've said earlier, right, having done
• 55:16
  authorisation or authorisation delegation is not enough, right?
• 55:21
  The, the, the, the reality is your authorisation decisions
• 55:24
  change over time. And this is where things like
• 55:27
  secure signals framework and ideas around dynamic
• 55:30
  authorisation come in. And Sean, I like this is kind of
• 55:33
  sort of looking at you as one of The Pioneers in this space.
• 55:37
  But really, I think one of the things that we, when we put this
• 55:41
  together was this, this acknowledgement, right?
• 55:45
  Authorization is dynamic. It changes over time.
• 55:49
  SSF provides you with a set of messaging standards and
• 55:53
  protocols for how to communicate that information throughout your
• 55:56
  system. Sean, I don't know if you want
• 55:59
  to add more to that. I think you're, you're spot on.
• 56:03
  And this is where elements of the of the stack that you can
• 56:06
  see and what you call it the aims framework.
• 56:09
  I don't wanna disappoint you, Peter, but but the aims
• 56:13
  framework right now, whatever, whatever background comes to
• 56:16
  mind, is it it gives you the, the I hate, I hate being cliche,
• 56:23
  but like the, the reactive fabric of like, oh, context
• 56:27
  changes. Like we should let an agent do
• 56:30
  something to a system if there isn't an open change ticket, not
• 56:33
  by a human being, but just because there's a window saying
• 56:36
  we can't do it. That's one example, but it's
• 56:38
  more around shared channels Framework gives you the ability
• 56:42
  to enable real time revocation and propagate it across all
• 56:45
  dependencies in the stack. And it's just, it isn't just
• 56:47
  going to match you. Like if you implement it at
• 56:48
  work. It's just, it's the protocol and
• 56:50
  mechanism so that when you're talking to many gateways,
• 56:54
  because we're going to have to in the identity world, you need
• 56:58
  one centralized again, one more buzzword, PEP policy enforcement
• 57:02
  point. The gateways should either look
• 57:04
  to one policy enforcement point that way.
• 57:06
  That way you can tie in all your signaling into that.
• 57:09
  So your gateways just become traffic cops that say yes, no.
• 57:13
  And then like Peter said earlier, depending upon
• 57:16
  architecture and layout, your transaction token service can be
• 57:19
  your IDP, it's own thing, be your, it could be part of your
• 57:22
  open ID provider. It could actually even be part
• 57:24
  of your gateway or gateways. Again, all yeses with pros and
• 57:29
  cons, but your gateway is like you're you're middle ground and
• 57:33
  and we didn't talk about it here because there's so much depth in
• 57:36
  the gateway that you get into like model poisoning agents,
• 57:40
  what you're allowing to use no hugging face, tons of stuff.
• 57:43
  That in itself is its own thing. If you want to actually decode
• 57:46
  that, pun intended, Jeff, But what does it give you in this
• 57:53
  stack? It gives you a, it gives you
• 57:55
  more real time monitoring of your environment and ecosystem
• 57:57
  that, that you hook up to your, to your, to a graph, to some
• 58:01
  data points that say the business may have shifted and
• 58:05
  changed and it's reactive and you have to ship it somewhere so
• 58:08
  that we know about it because there's business and there's
• 58:11
  security context. So I'll give you an, an example
• 58:14
  is if you have an an autonomous agent, for example, the gateway
• 58:19
  could receive a Cape event CAEP continuous access evaluation
• 58:24
  profile. You now can downscope or revoke
• 58:28
  tokens mid flight. And there's a new concept that
• 58:32
  we have talked about, yeah, call identity brokering.
• 58:34
  But that's where you could stop and mid to stop Mindy tokens for
• 58:37
  that agents and revoke all sessions were transactions or
• 58:42
  instances without writing a policy intervention or calling
• 58:47
  the SoC level 1 level 2 and saying listen, listen, this
• 58:49
  thing shifted. Kill it mid flight.
• 58:52
  And it's literally because data came in and said this agent's
• 58:57
  acting rogue because we've seen too many requests like Peter
• 58:59
  said earlier, like you're trying to access the system 4567 times
• 59:03
  and heuristically, it's like you've never asked this.
• 59:05
  Something's weird. Don't kill it.
• 59:08
  Just turn it off and see what's happening.
• 59:10
  That is kind of like saying the I hate using this word, but the
• 59:15
  system tightens itself automagically based on ever
• 59:19
  evolving and ever changing conditions.
• 59:21
  And that I think that piece, integrating it into all layers
• 59:24
  of the stack, it's so important and it's not vaporware anymore.
• 59:27
  It works. It it it works in prod right
• 59:31
  now. I feel like this is a probably a
• 59:33
  good spot to try and hopefully make this real, right?
• 59:36
  We've been talking a lot of like how this fundamentally works,
• 59:39
  you know, from like a spec, you know, standpoint.
• 59:43
  Can we kind of transition to, OK, that's cool, Peter, how do I
• 59:48
  do this? What does this look like in the
• 59:49
  real world and shine? I'd love to hear your thoughts
• 59:51
  because obviously you've you've built some of the stuff as well,
• 59:54
  but where do we how do we make this real for the people
• 59:57
  listening? Well, I think the like so
• 1:00:00
  everything that we've talked about have real world
• 1:00:03
  deployments, right, You can use these things today, right, You
• 1:00:07
  can go and have you can. You can deploy spiffy.
• 1:00:10
  There are open source options that are commercial offerings,
• 1:00:15
  right And you there is really and we see this, you know,
• 1:00:21
  talked about the scale at which some of these things run, you
• 1:00:23
  know, billions of credentials a day at, you know, really large
• 1:00:28
  like, you know, very large companies.
• 1:00:31
  This is not a this is not a theoretical thing.
• 1:00:34
  You can do that. You can provision those spiffy
• 1:00:38
  credentials with X five O 9, the certs and Jots and in the near
• 1:00:43
  future they'll have workload identity tokens and you can use
• 1:00:46
  them and you can use them with O auth to do these delegation
• 1:00:50
  scenarios today, right? Token exchanges are well
• 1:00:54
  supported. Several ID PS do support them.
• 1:00:58
  You can use spiffy credentials with O auth.
• 1:01:03
  What's the auth lead actually supports that key Cloak supports
• 1:01:10
  that. And I believe you can actually
• 1:01:12
  use specific credentials for things like Bing and and Octo as
• 1:01:14
  well, right? Like you can use these
• 1:01:17
  credentials with existing ID PS and so that that's already
• 1:01:23
  there, right? So it's really there.
• 1:01:25
  I think there are things that you may have to do in terms of
• 1:01:28
  like to, to Sean's point, right, you may have to put a gateway in
• 1:01:31
  place because it gives you central control, right?
• 1:01:34
  You may want to have that gateway in place specifically
• 1:01:37
  because you don't have the time to go and update every bit of
• 1:01:40
  authorization logic you have to reason over the claims inside
• 1:01:46
  an, an O auth access token. And you do have to integrate
• 1:01:52
  with your existing authorization system.
• 1:01:53
  In fact, we didn't talk about policy based access control,
• 1:01:57
  RBAC, ABAC, rebag, all of these things.
• 1:02:00
  They're also deployed out there, right?
• 1:02:01
  And, and the, this is very important.
• 1:02:04
  The O auth access token is 1 input to your authorization
• 1:02:07
  decision. It carries really important
• 1:02:10
  information about the subject and the agent, but that is not
• 1:02:15
  the that's not the end of the authorization decision, right?
• 1:02:19
  There's this whole other set of authorization machinery, and
• 1:02:22
  that's often some integration that's needed.
• 1:02:24
  There are standards like old Zen emerging that should make that
• 1:02:27
  easier. But that is that's pretty real.
• 1:02:32
  And then I think Sean, I think our, our friends at Signal have
• 1:02:36
  been implementing some of the SSF concepts at least.
• 1:02:39
  You can probably speak more to that.
• 1:02:41
  But I think one of the observations, Jeff, is like
• 1:02:44
  this, everything that we talked about here, it's not
• 1:02:48
  theoretical, right? You can.
• 1:02:49
  You can. Actually, you can already do
• 1:02:53
  these kinds of deployments, you just actually have to know that
• 1:02:57
  you can. Peter, you get a you get on
• 1:02:59
  something that's pretty important policy based access
• 1:03:01
  control. There's a lot of opinions out
• 1:03:04
  there about read back feedback. There's star back pretty much
• 1:03:07
  right now. I don't want to add to the the
• 1:03:10
  acronym salad here, but looking at this from a governance line,
• 1:03:15
  a governance lines, but even AGRC lens, there is no human way
• 1:03:20
  to scale this, no human way. And the only thing that makes
• 1:03:25
  sense to say is all H example, all HR based agents can get
• 1:03:30
  access to these five systems. That's scoping it.
• 1:03:35
  And then you can go one level deeper and say all HR based
• 1:03:38
  agents who were tasked with being a monitor can do right to
• 1:03:41
  this. That's a policy.
• 1:03:44
  You have to look at it from a policy perspective because if
• 1:03:47
  you do it at the instance level, I can't, I mean, happy to be
• 1:03:54
  wrong, but I, I don't unless you have money to, unless here's the
• 1:03:57
  money tree, you can shake it. It's like it's coming down, but
• 1:03:59
  I don't, I don't, I don't see it.
• 1:04:01
  I don't. No, I agree.
• 1:04:03
  When you deal with singletons, you're going to fail because the
• 1:04:06
  scale is going to overwhelm you for sure that I think that 100%
• 1:04:13
  agree. The other thing Jeff, that I
• 1:04:15
  would say is we're not living in a fixed world, right?
• 1:04:19
  I, I think one of my one other thing up until if you asked me
• 1:04:24
  this question last Monday, I would have said, you know you
• 1:04:28
  can deploy these things, but right when you're calling
• 1:04:33
  Anthropic, for example, you have to have an API key.
• 1:04:36
  It turns out as of last Tuesday, that is no longer true, right?
• 1:04:40
  And so these, I think what we're also beginning to see is this
• 1:04:43
  shift happening as these agentic platforms is finding more
• 1:04:48
  deployment in enterprises. The reality sort of arrives,
• 1:04:52
  right? And it's like, well, you cannot
• 1:04:53
  just have API keys. And so I think last Tuesday
• 1:04:57
  Anthropic introduced workload identity Federation.
• 1:05:00
  And so now you can have one of these specific credentials and
• 1:05:03
  you can go and you can authenticate your APIs and
• 1:05:07
  Anthropic without having a pre established secret, right.
• 1:05:10
  That's pretty huge. And so I think the other thing
• 1:05:13
  is that I would say, I think, Sean, you raised this point
• 1:05:17
  maybe earlier when we were talking, having a conversation
• 1:05:22
  with your providers about the capabilities that you need to
• 1:05:26
  run your enterprise securely. You absolutely have to do that,
• 1:05:31
  right? And because that's when it
• 1:05:33
  becomes like, Oh yeah, of course, you cannot scale, you
• 1:05:35
  cannot deploy, you cannot govern, you do not have control.
• 1:05:40
  And then the question is, well, how do you do that?
• 1:05:41
  And it's like, well, there's a standards road map or a
• 1:05:44
  standards blueprint that's mostly there.
• 1:05:47
  It requires maybe a feature addition here, an extension
• 1:05:51
  there, right? A capability that needs to be
• 1:05:53
  deployed as part of a gateway or deploy a gateway, things like
• 1:05:57
  that, right? But I think, I think our earlier
• 1:05:59
  point, I, I, I don't think we want to say, oh, we've got it
• 1:06:02
  all, but 95% right? You, there's a huge amount that
• 1:06:08
  you can just pretty much use off the shelf.
• 1:06:10
  And for the rest, talk to your providers, right?
• 1:06:13
  Especially if it's a deployment blocker.
• 1:06:15
  The foundation solid, it works 100%.
• 1:06:19
  Another another good one you mentioned Anthropic is Google
• 1:06:22
  announced the agent ID and it's based off spiffy.
• 1:06:24
  It's really it's great. So those of you who are in who
• 1:06:27
  are in Google to deploy anything on vertex or in different realms
• 1:06:31
  there, there's no more service principal service agent.
• 1:06:34
  That's just you now hanging entitlements off of an agent ID
• 1:06:38
  and it works great. I think that the next layer is
• 1:06:43
  interoperability because most big companies aren't all in on
• 1:06:46
  vendor platform XY and Z. It's the lovely F word, not that
• 1:06:50
  one federation like how do you talk?
• 1:06:54
  How do you interop? And that's the a lot of vendors
• 1:06:58
  are missing that boat. And I think as practitioners or
• 1:07:00
  as executives or product folk or engineers, be vocal, be like how
• 1:07:05
  do I talk to this for over here without having to set up another
• 1:07:09
  account or an API key like I I want one way.
• 1:07:12
  Yeah, that, that absolutely right, that law of a genetic
• 1:07:15
  utility, this is a very expensive retooling that every
• 1:07:20
  enterprise is going through and everybody should be insisting on
• 1:07:24
  getting value from it. And you're going to get the most
• 1:07:27
  value out of your agents if it can actually access all the
• 1:07:30
  information across all your cloud and on Prem environments.
• 1:07:34
  And to your point, Sean, like I think there is no such thing as
• 1:07:37
  a single platform environment anymore.
• 1:07:42
  I, I remember talking to somebody about this and they
• 1:07:45
  were telling me it's like, oh, Peter, we don't need
• 1:07:48
  cross-platform. We're a single platform company.
• 1:07:51
  And then six months later they came back and they said, well,
• 1:07:54
  we were a single platform company and then we acquired
• 1:07:57
  this other company and now we're a multi platform company, right?
• 1:08:01
  So M and I like, I think we, there's nobody lives in a single
• 1:08:06
  platform world anymore. It's great that every platform
• 1:08:09
  is taking identity seriously. But to Sean's point, right, if
• 1:08:14
  we really want to unlock the value of agentic use cases, you
• 1:08:19
  we're going to have to have cross cloud and cross-platform
• 1:08:22
  access. That is that's going to be the
• 1:08:24
  key. And that's all identity, right.
• 1:08:27
  Agentic identity is going to be the thing that non human good
• 1:08:31
  old workload identity. That's the thing that unlocks it
• 1:08:34
  for you. And Jeff, I know we probably
• 1:08:36
  should rap. I just want to say one last
• 1:08:38
  thing as a practitioner is if you look at this from an agentic
• 1:08:44
  lens work agentic workload lens, you can go backwards and this
• 1:08:52
  works for machine identity which they are different.
• 1:08:56
  I will debate that all day on linked to anybody they wanted to
• 1:08:59
  want to debate it. But how you do this for machine
• 1:09:02
  identities and agentic ones, it works both ways.
• 1:09:06
  And if you do it, if you figure out the hardest use case is
• 1:09:09
  agentic, it works for machines. And if you do it the hard way,
• 1:09:14
  the users come organically. Not saying for free because they
• 1:09:18
  don't come for free because it's just organically it does.
• 1:09:21
  It's very interesting how the how AI has compressed the time
• 1:09:25
  frame to figure out the classic IAM problem.
• 1:09:27
  Who has access to what, where and why And it's should they
• 1:09:31
  have access to the right resource at the right time for
• 1:09:33
  the right reasons. Replace The Who with the what.
• 1:09:36
  Put them together and you have Nirvana.
• 1:09:39
  If you build an easy way to do it, that's where people will
• 1:09:41
  come so. That's.
• 1:09:45
  That's the way to do it. Like it's, you know, I, I, I
• 1:09:48
  won't take this down the product path.
• 1:09:49
  And I, when I say product, I mean like vendor.
• 1:09:51
  What I mean is like this idea of having whimsy, Spiffy Spire and
• 1:09:57
  SSF, right combined that as the product of how you do agentic
• 1:10:03
  identity. Like that's the way that at
• 1:10:06
  least right now, as of the year 2026, this is the way we're
• 1:10:08
  approaching it. And if, if those are standards,
• 1:10:13
  they're built, they're ready to go and people will use them,
• 1:10:17
  right? That becomes the methodology
• 1:10:19
  that and the framework that people should be using, adopting
• 1:10:21
  going forward. Yeah, the pit of success, right?
• 1:10:25
  I think that this is the picture we're trying to paint for
• 1:10:27
  people. It's the pit of success.
• 1:10:28
  You're going to fall into this thing.
• 1:10:31
  Everything else is to be harder. That that is, I think
• 1:10:34
  absolutely. And and that is the benefit of
• 1:10:37
  reusing stuff, Jeff, right. Building on the work of the last
• 1:10:40
  decade, you're going to get so much further and, and do you
• 1:10:45
  think it's hard to to deploy infrastructure that's been
• 1:10:48
  around for a decade, wait till you deploy infrastructure that
• 1:10:52
  hasn't been built yet, right? That's way harder.
• 1:10:55
  I'm just going to have AI do it for me and I'm sure it'll work
• 1:10:57
  totally fine. You know, who knows, maybe that
• 1:11:01
  is the answer, right? But I to your there's also
• 1:11:05
  evidence to suggest that that come that could come with
• 1:11:08
  adverse outcomes sometimes. Yeah, I've seen the matrix.
• 1:11:13
  I know how this ends. We're batteries.
• 1:11:15
  That's the way it ends up. You spoiled the end of.
• 1:11:18
  You can see the matrix job. You know what?
• 1:11:20
  It's been 25 years. I think.
• 1:11:23
  You know, I hate to say it, but I think if you haven't seen it
• 1:11:25
  by now, chances are you probably aren't going to.
• 1:11:30
  All right, anything else we want to cover?
• 1:11:32
  Like, you know, Peter, this has been very educational, at least
• 1:11:35
  for me, and I hope for others as well.
• 1:11:36
  Like what's the what's the main take away here?
• 1:11:39
  Like if I said I just got into an elevator with my CSO or CIO
• 1:11:45
  or somebody who's in charge of helping facilitate this at the
• 1:11:47
  executive layer, give me like the 32nd to a minute elevator
• 1:11:51
  ride of how I can explain this to someone and try to get their
• 1:11:55
  buy in. I would say the key to solving
• 1:12:00
  your agentic AI identity challenges is to realize that
• 1:12:05
  agents are workloads. And the moment you do that, you
• 1:12:09
  have 95% of the problem solved because there are standards and
• 1:12:13
  products that implement those standards available today off
• 1:12:16
  the shelf. The remaining 5% are gaps that
• 1:12:19
  the industry is actively filling.
• 1:12:22
  And and then there's an integration aspect, right, that,
• 1:12:25
  that you may want to go and look at.
• 1:12:28
  And this is for things like gateways and other kind of
• 1:12:30
  architect, you know, deployment architecture comes in, but it's
• 1:12:34
  not, you know, I think the tools are there, the products are
• 1:12:38
  there, the gaps are being filled.
• 1:12:42
  And you know, what's that? I, I have the, the, the saying
• 1:12:48
  from Saint Francis office CC, right?
• 1:12:51
  Start by doing what's possible, right?
• 1:12:55
  Or starts on doing what's necessary.
• 1:12:57
  And then you can start doing what's possible.
• 1:12:59
  And before you know it will do the impossible, right?
• 1:13:01
  And we already have all the tools to get us to possible and
• 1:13:04
  possibly even some of the things we thought in the past was
• 1:13:07
  impossible. The tools are there.
• 1:13:09
  That was a great LinkedIn post, by the way.
• 1:13:10
  Yeah, that's the great LinkedIn post way to do it.
• 1:13:13
  Sean, how do you want to end this?
• 1:13:15
  Like do you have any words of wisdom for people out there?
• 1:13:18
  I think not Wisdom, that's fine too.
• 1:13:20
  Oh, I know, I'm just trying to think about it on top of my
• 1:13:22
  head, but it's more around. This is not far from reach.
• 1:13:29
  Even if you do two of these things, you're better.
• 1:13:32
  You'd build on it little by a little.
• 1:13:34
  And I think the like if I were in an elevator with my with AC.
• 1:13:39
  So I'd say what you don't know should bother you.
• 1:13:45
  Like there's blind spots to ages all over the place, and that's
• 1:13:47
  just going to take one heck up and you're going to be no one
• 1:13:51
  wants to be on the front page of the news.
• 1:13:52
  No, no one wants that. Right, but grounding in truth
• 1:13:56
  that identity is a first party principle in a gentic workloads.
• 1:14:00
  That is the most true statement on anywhere that should be
• 1:14:04
  before that is a prime directive in anything to do with AI.
• 1:14:09
  If you if you don't have a registry or a catalog of what's
• 1:14:12
  due or what you're blind. The take away from this is the
• 1:14:17
  standards are there, they're real, are they perfect?
• 1:14:20
  We would argue kind of they're getting there, but it's enough
• 1:14:24
  to say you can't look at your leadership and say well, they're
• 1:14:29
  still evolved and we don't know yet.
• 1:14:31
  I think that time's gone. It's there.
• 1:14:33
  It's it's now you we going and going and doing it now is the
• 1:14:37
  right approach to take and it isn't vapor where you're not
• 1:14:39
  wasting money. This is this is legitimately
• 1:14:42
  standards will make AI palatable 'cause you don't want to re emit
• 1:14:48
  the wheel with oh, a new model, a new this hall.
• 1:14:51
  Can I go read? No, no, it's base primitives.
• 1:14:54
  Here's your control plane, your data plane, later on all the all
• 1:14:57
  the new stuff. Won't matter.
• 1:15:00
  You know that that's such an interesting observation, Sean.
• 1:15:02
  It's, it's a pattern that I've seen emerging over the last six
• 1:15:05
  months and, and another bit of guidance decouple your identity
• 1:15:09
  plane from your platforms and your your frameworks, right.
• 1:15:13
  And I, I was at the MCP Dev Summit talking to folks and it
• 1:15:17
  was really interesting to see how many folks are arriving at
• 1:15:19
  this conclusion. It's like I'm going to be on
• 1:15:22
  multiple platforms. I need to decouple my identity
• 1:15:24
  layer because otherwise it's going to be impossible for me to
• 1:15:29
  actually achieve the outcomes that I need.
• 1:15:31
  Look, there's so much to pick up here.
• 1:15:33
  We're going to have links in our show notes.
• 1:15:35
  Peter's been kind of send over at least one.
• 1:15:37
  I'm sure they'll probably like 40, but send them over my way.
• 1:15:40
  We'll include them in our show notes for people to take a look
• 1:15:41
  at. You know, if you get a chance to
• 1:15:44
  have these conversations, please do so.
• 1:15:47
  Not everybody in IAM is a developer and not everybody who
• 1:15:50
  is a developer is in IAM. And the only way this works is
• 1:15:53
  if we start asking questions. And I think for the people out
• 1:15:56
  who are out there is like I am practitioners that, you know,
• 1:15:59
  are in charge of some portion of their identity security is go
• 1:16:02
  out and start asking these questions.
• 1:16:04
  Some of these problems have been solved.
• 1:16:06
  Some of them are being solved actively right in the industry.
• 1:16:09
  So start asking questions, you know, how are we doing this?
• 1:16:13
  How are we protecting the workloads?
• 1:16:15
  How are we handling authentication authorization?
• 1:16:18
  You know, for these agents, there is a lot of information
• 1:16:21
  that kind of out there and you know, these are the types of
• 1:16:23
  questions that you need to be asking.
• 1:16:24
  So I know I learned a lot today. I especially learned that we
• 1:16:28
  have some really great acronyms, especially in this space of the
• 1:16:31
  world. You know, we're getting smarter.
• 1:16:33
  Maybe we, you know, just focus on making acronyms funnier and
• 1:16:36
  people, you know, funnier or more interesting and, you know,
• 1:16:39
  that'll help drive people towards, you know, this whole
• 1:16:41
  thing is a product as well. So, you know, Peter, I
• 1:16:44
  appreciate your time. You know, web link to you as
• 1:16:46
  well on our show notes so people can reach out, you know, if they
• 1:16:49
  have questions. And then Sean, I think this is
• 1:16:51
  something you and I are going to do from time to time.
• 1:16:53
  It's kind of the standards approach.
• 1:16:54
  Get a little more detail into it.
• 1:16:57
  I don't know where we're going to go next.
• 1:16:59
  Have you thought about what our next Decoded episode is going to
• 1:17:02
  cover? I think so I think it's either
• 1:17:05
  going to be a mixture of I have, I have some dealers out for
• 1:17:08
  transaction tokens as as the next follow up the deep dive.
• 1:17:12
  The other, the other fun one I think we can get into is I want
• 1:17:16
  to say consent, but that's a very dirty word right now.
• 1:17:19
  But I think transaction tokens have a lot of applicability
• 1:17:22
  coming up relatively soon. So reached out to a few people
• 1:17:26
  who who are interested in who are interested in talking.
• 1:17:28
  So I think it's going to be transaction tokens or not likely
• 1:17:31
  next. OK, and that'll be something to
• 1:17:35
  look forward to. And then if you've got
• 1:17:36
  suggestions out there for areas you want to take, you know, the
• 1:17:39
  standards conversation river send them to to Sean and or
• 1:17:42
  myself. LinkedIn is probably the best
• 1:17:43
  way to do that. I will have LinkedIn connections
• 1:17:46
  for us as well in our show notes.
• 1:17:48
  So so yeah, that was our our first decoded by Jenny de
• 1:17:51
  center. Hopefully people enjoy that.
• 1:17:53
  Hopefully people learn something and we'll talk with everyone in
• 1:17:57
  the next one. That was decoded by identity at
• 1:18:04
  the center. Visit idacpodcast.com for more
• 1:18:09
  digital identity conversations.