The AI Control Loop: What's Missing in AI Security Today - with Craig Thomas of Wallarm

Wednesday, July 08, 2026 • 20:16 listen • Bonus

Listen to Episode

The AI Control Loop: What's Missing in AI Security Today - with Craig Thomas of Wallarm

Code Story: Insights from Startup Tech Leaders

0:00 20:16

Today, we are dropping another episode in our series The AI Control Loop, How enterprises govern the AI they've already deployed - sponsored by our friends at Wallarm.

Wallarm is the AI Control Platform for Enterprise AI, protecting every AI workload, API, and application in production, giving CISOs the governance they need and CIOs the speed they demand. Organizations choose Wallarm for a complete inventory of APIs, AI agents, and AI apps, patented AI/ML-based threat detection and blocking that operates at production traffic speeds.

In today's episode, Craig Thomas, Sr. Solutions Engineer at Wallarm, returns to the show to dive into why runtime behavior is the critical blind spot, and what CISOs should demand if they want to move from policy to control.

Questions

Security teams are used to detecting incidents and responding after the fact. Why is that model becoming insufficient for AI-driven systems?
Building on that, when we talk about response today, enforcement often means actions like restarting pods, rotating credentials, or shutting down services. Why can those measures come too late in an AI environment?
So if traditional response isn't enough, why does AI behavior require controls that operate much closer to runtime?
And when people hear "runtime enforcement," they may think of existing security controls. What changes when enforcement happens at the kernel level rather than only at the network, identity, or application layer?
Can you make that tangible for us? What does it actually mean to revoke or contain a compromised AI session without disrupting the broader deployment?
How does that kind of real-time containment change the risk equation for AI agents that have access to sensitive data, external services, or production workflows?
With that in mind, what are some examples of AI behaviors that organizations should be able to stop immediately?
Of course, security teams also don't want to become a bottleneck. How do organizations balance strong enforcement with the need to keep AI development and deployment moving quickly?
And once organizations have the ability to discover, observe, and enforce AI behavior in real time, how does that change accountability at the enterprise level? What does good governance look like from there?

Links

Full Abstract

This episode examines what is actually missing in AI security today. Craig Thomas, Sr. Solutions Engineer at Wallarm, dives into why runtime behavior is the critical blind spot, and what CISOs should demand if they want to move from policy to control.

CIOs and CISOs have moved past debating whether AI security matters. The question now is what to actually do about it, and most organizations are finding that their existing tools answer a different question than the one AI is asking.

Traditional security tools were built around access: who can reach a system, what credentials they present, what traffic looks like at the perimeter. AI shifts the problem to execution: what a system does once it has access, whether that behavior matches what the business intended, and how you know when it doesn't. Most current tooling has no answer for that. It can tell you what is deployed and what is configured. It cannot tell you what your AI is actually doing at runtime, on whose behalf, or whether any of it violates the policies you thought were in place.

That gap is where most AI security programs stall. There is no shortage of governance frameworks, compliance checklists, and vendor claims. What is missing is operational control: the ability to see AI behavior as it happens, enforce policy at runtime, and produce evidence that holds up when an auditor or a board asks for it. The four capabilities that define a closed AI control loop, discover, observe, enforce, govern, are well understood as a category. Getting all four working together in production is where the real work begins.

Our Sponsors:
* Check out Cash App and use my code CASHAPP10 for a great deal: https://cash.app
* Check out Plaud AI and use my code CODESTORY for a great deal: https://plaud.ai

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

[SPEAKER_01]: Hello listeners, today we are dropping another episode in our series The AI Control Loop.

[SPEAKER_01]: Out Enterprise is governed the AI they've already deployed, sponsored by our friends at Walmart.

[SPEAKER_01]: Walmart is the AI Control Platform for Enterprise AI, protecting every AI workload, API, and application in production, giving CSOs the governance they need and CIOs the speed they demand.

[SPEAKER_01]: Organizations choose Wallarm for a complete inventory of APIs, AI agents, and AI apps using patented AI ML-based threat detection and blocking the operates at production speeds.

[SPEAKER_01]: In today's episode Craig Thomas, Senior Solutions Engineer Wallarm, returns to the show to dive into why runtime behavior is the critical blind spot.

[SPEAKER_01]: And what CISO should demand if they want to move from policy to control?

[SPEAKER_01]: Craig, welcome back to the show.

[SPEAKER_01]: Thank you for being in a return episode on code story.

[SPEAKER_00]: Yeah, great to be back.

[SPEAKER_00]: I know last time we talked about Rogue AI, so excited to dive in deeper about the threats and how to solve some of the AI problems today.

[SPEAKER_01]: Absolutely really digging and really enjoying this the series we're putting together here title for today is what's missing in AI security today.

[SPEAKER_01]: We're going to dive into runtime behavior being a critical blind spot and what CISO should demand and let's dive right into it.

[SPEAKER_01]: So security teams are used to detecting incidents and responding after the fact, right?

[SPEAKER_01]: We've covered that quite a bit in the series.

[SPEAKER_01]: Why is that model becoming insufficient for AI driven systems?

[SPEAKER_00]: Yeah, great question, Noah.

[SPEAKER_00]: First of all, just kind of like the frame this whole discussion, right?

[SPEAKER_00]: The traditional security really was built to answer one question, who gets access?

[SPEAKER_00]: Firewall rules, identity access policies, network segmentation, all that's fundamentally controlling the gate.

[SPEAKER_00]: But AI has to move that problem past the gate.

[SPEAKER_00]: And so, yes, about detecting respond to systems.

[SPEAKER_00]: Traditional hour assumes a human attack or moving it human speed.

[SPEAKER_00]: You have time to detect, triage, contain that attack.

[SPEAKER_00]: But as we talked about before and some of the other episodes, AI compresses that timeline dramatically.

[SPEAKER_00]: Model connects will trade, manipulate, corrupt data in milliseconds versus hours, days or even weeks.

[SPEAKER_00]: And so this incident with AI may not look like an incident, looks like normal API calls, normal outputs, and traffic.

[SPEAKER_00]: I like to think about it about how incident response was designed.

[SPEAKER_00]: Traditionally, someone breaches the perimeter.

[SPEAKER_00]: They move laterally out over hours, days, weeks, your sim fires, and alert.

[SPEAKER_00]: Sock analyst opens a ticket.

[SPEAKER_00]: That mental model all assumes time.

[SPEAKER_00]: AI just doesn't give you that time anymore.

[SPEAKER_00]: And so if that prompt injection or that attack causes your AI agent to start dumping customer records to an external endpoint, that loop closes in seconds.

[SPEAKER_00]: So by the time your sim would no more fire, the data's already gone and detecting a response, built for a world where attackers are slower than defenders.

[SPEAKER_00]: But as Flynn, as we've talked about, AI flips that assumption today.

[SPEAKER_01]: It sure does.

[SPEAKER_01]: It moves so fast and these models that have been built in the past just really don't.

[SPEAKER_01]: They really don't keep up and building on that when we talk about response today and enforcement often means actions like restarting pods or rotating credentials or shutting down services.

[SPEAKER_01]: Things like that.

[SPEAKER_01]: Why can those measures come too late even in an AI environment?

[SPEAKER_00]: Those are stateless remediation, applied to stateful harm, but the damage is already done, it's already materialized.

[SPEAKER_00]: AI agents often hold open sessions with those external services, so rotating a credential after the agent has already acted doesn't undo the action.

[SPEAKER_00]: and so that's really what we have to fundamentally look at.

[SPEAKER_00]: I like to equate it to restarting a pod is like locking a door after someone's already walked out with your files.

[SPEAKER_00]: It's good, they're clean, you're good now, but it doesn't matter.

[SPEAKER_00]: It really in that traditional sense that traditional web app, the worst case of a single compromise is usually bounded.

[SPEAKER_00]: A one record touch,

[SPEAKER_00]: that has that tool used that single compromise session.

[SPEAKER_00]: I've already browsed your internal wiki, drafted an email, scheduled a meeting, queared your CRM.

[SPEAKER_00]: All that happened before your orchestration layer or those pod restarts happened, right?

[SPEAKER_00]: You can't unsend that email by rotating their credential or simply restarting that pod.

[SPEAKER_01]: right on.

[SPEAKER_01]: Okay, so if traditional response isn't enough, and I think we have established that for sure, why does AI behavior require controls that operate so much closer to runtime, and the engineer in me is being liked.

[SPEAKER_01]: We're touching on this in different areas, but I want to be clear in why that's important.

[SPEAKER_00]: It's really static controls.

[SPEAKER_00]: These firewall rules, I am policies.

[SPEAKER_00]: They can't evaluate intent.

[SPEAKER_00]: And so a lot of looking at AI is really about that intent.

[SPEAKER_00]: That semantic drift.

[SPEAKER_00]: It's moved.

[SPEAKER_00]: This threats move from who gets in to what happens after they're in.

[SPEAKER_00]: So you're assuming these credentials are legit.

[SPEAKER_00]: But then once they get in, that spreads.

[SPEAKER_00]: So the shift really moves from traditional security being essentially that gate.

[SPEAKER_00]: You check their credentials check.

[SPEAKER_00]: They're good.

[SPEAKER_00]: You check the traffic.

[SPEAKER_00]: Yep, that looks good.

[SPEAKER_00]: You let it through where you don't.

[SPEAKER_00]: But once that AI agent with legitimate credentials, legitimate network access happens, your gate controls are done.

[SPEAKER_00]: They're in.

[SPEAKER_00]: They've already done their job.

[SPEAKER_00]: So now that question, but it moves from what the agent does next.

[SPEAKER_00]: Does it behave consistently with business intent that you desire?

[SPEAKER_00]: Does it stay in scope?

[SPEAKER_00]: Does it just keep

[SPEAKER_00]: Or does it start doing things that look fine individually, but harmful in aggregate?

[SPEAKER_00]: None of that happens at the gate.

[SPEAKER_00]: Really, that's the runtime question.

[SPEAKER_00]: So if you don't have controls that operate at runtime, as we've been talking about for AI security and API security for a while, right, if you don't have those controls that operate at runtime, you really have no controls for that class of the problem.

[SPEAKER_00]: don't like to just be a scare-monger right there.

[SPEAKER_00]: There are solutions and we're starting to see those solutions for how a CSO can gain this access and enable the business, but it has to shift from gate controls to runtime controls.

[SPEAKER_01]: Right on, okay, so we're going the level down there when people hear runtime enforcement.

[SPEAKER_01]: They may think of existing security controls, right?

[SPEAKER_01]: What changes when enforcement happens at the kernel level in the runtime rather than only up the network identity or application layers?

[SPEAKER_00]: Yeah, so those network identity layers to talk a little bit about already, but they see who and where, but they aren't really seeing what.

[SPEAKER_00]: The application layer does see inputs and outputs, but no kind of intermediate behavior, what tools were called, what memory was accessed, what reasoning steps were taking.

[SPEAKER_00]: And so shifting that to kernel level visibility, it actually sees those system calls, the file I owe the process behavior,

[SPEAKER_00]: what the model is actually doing versus just what the model is called on the host and not just what it's saying at that API boundary.

[SPEAKER_00]: And if you're only watching certain layers, you're only watching that front door aspect.

[SPEAKER_00]: And so as you dive in the kernel layer, you get the aggregate of all these things.

[SPEAKER_00]: And you need all those things at run time to truly see and shift and protect in real time the whole picture.

[SPEAKER_00]: And then, like we talked about, that enables you leverage AI within your environments to get with the most from the AI that you're investing in for both the internal processes as well as customers.

[SPEAKER_01]: Can you make that a bit more tangible for us, and I think for the audience, what does it actually mean to revoke or contain a compromised AI session without disrupting the broader deployment?

[SPEAKER_01]: Because if you think linear and it's all part of the same, a similar workflow, and there's a process, if you cut a chunk in that workflow, kills the workflow.

[SPEAKER_01]: So tell me a little bit more about that.

[SPEAKER_01]: Make it more tangible for us.

[SPEAKER_00]: Yeah, great question.

[SPEAKER_00]: You've got a shift from these broad controls to being more scalpel-like, right?

[SPEAKER_00]: So session level containment talks about terminating or sandboxing just a single agent's execution without taking down the model, the infrastructure, or adjacent sessions, right?

[SPEAKER_00]: So you have to continue to enable the business while blocking that individual attacker or rogue AI agent from there.

[SPEAKER_00]: So, look at it like killing a single process without rebooting the whole server.

[SPEAKER_00]: But in order to do that, you need the instrumentation to identify the right process.

[SPEAKER_00]: In practice, you revoke the session token or you freeze pending tool calls and that execution context.

[SPEAKER_00]: You also need to preserve the session artifacts for forensic so you can see what has happened.

[SPEAKER_00]: But you allow those other sessions to continue.

[SPEAKER_00]: So, I was like that from an analogy perspective,

[SPEAKER_00]: If you have a compromise of a count and an enterprise SaaS environment like Salesforce, if a single user session gets hijacked, you don't shut down for everyone.

[SPEAKER_00]: You kill that session, you invalidate that token, you audit what that session touched.

[SPEAKER_00]: AI needs those same parameters.

[SPEAKER_00]: Primitives.

[SPEAKER_00]: The problem is most organizations don't have them yet.

[SPEAKER_00]: They kill the pod, which we talked about earlier, which kills everything, or they do nothing.

[SPEAKER_00]: There's really no middle options.

[SPEAKER_00]: So what real containment looks like, that I can identify the session that's misseth behaving, terminate exactly.

[SPEAKER_00]: That execution context and preserve what it did for investigation.

[SPEAKER_00]: Providing some feedback, we're going to talk about how do you provide feedback to developers, but provide that feedback?

[SPEAKER_00]: But then leave everything else running.

[SPEAKER_00]: So that's a technical capability gap for most teams right now that folks are looking at how do we do that?

[SPEAKER_00]: But that's really the angle of being able to revoke or contain that session without breaking everything.

[SPEAKER_01]: That makes sense.

[SPEAKER_01]: Okay.

[SPEAKER_01]: So when we move into this type of real-time containment and thinking about the risk for AI agents and them having access to things, how does this kind of real-time containment change the risk equation?

[SPEAKER_01]: When AI agents have access to sensitive data external services, production workflows are essentially doing the work of a that you would that a human would do, how does the real-time containment change the risk?

[SPEAKER_00]: Let's look at what it looks like without that containment.

[SPEAKER_00]: That blast radius of a compromised agent is unbounded, right?

[SPEAKER_00]: It has whatever access it was granted.

[SPEAKER_00]: So if that user or that session has full access to go do whatever it wants, you're unbounded.

[SPEAKER_00]: With containment that blast radius shrinks dramatically, it's bounded by detection latency, the faster you see at the less damage can accumulate.

[SPEAKER_00]: And so this changes how you reason about those agent permissions.

[SPEAKER_00]: You can grant broader access if you have confidence in your ability to contain quickly without that confidence, you're forced into over restriction, which then ultimately limits utility.

[SPEAKER_00]: And I think it's really important reframe for CISOs thinking about AI age in architecture, right?

[SPEAKER_00]: As a previous CISO and dealing with those day and a day out, right now the dominant strategy is least privilege taken to an extreme.

[SPEAKER_00]: You give the age in almost nothing and hope it can still be useful.

[SPEAKER_00]: Then the business comes back to either mad, that this age in isn't very useful, and you're the bad guy again, right?

[SPEAKER_00]: That, so that works until the business decides it really needs that agent to actually be useful and now you're in a fight.

[SPEAKER_00]: But the good news is if you have real containment capability, that really that calculus can change, can grant broader permissions because you're confident that if something goes wrong, you can catch it fast and the damage is bounded like we talked about.

[SPEAKER_00]: Security stops being the ceiling on that utility and starts being the foundation that makes higher utility possible.

[SPEAKER_00]: I really like to see so can now enable the business, provide the security, provide the governance versus just having to stalk the progress as you start to get the this additional visibility and confidence.

[SPEAKER_01]: Right on, what are some examples of AI behaviors that organizations should be able to stop immediately when they move to your runtime enforcement?

[SPEAKER_00]: Yeah, a couple jump demand right away, you know, a data movement outside the approved endpoint.

[SPEAKER_00]: If a model is exfiltrating to unexpected destinations, you need to know when your data is leaving, right?

[SPEAKER_00]: Because that becomes a real pain point and has some real legal and monetary consequences.

[SPEAKER_00]: So that's one.

[SPEAKER_00]: Another is prompt injection executing, especially when it alters the agent's stated goal or override systems instructions.

[SPEAKER_00]: A tool that exceeds scope, but it's supposed to do A and B, but now it's doing C, right?

[SPEAKER_00]: Or it's supposed to have red access only, but now it's making right into leaked calls.

[SPEAKER_00]: You should be able to see and stop that immediately.

[SPEAKER_00]: Another one similar to we, we've looked at for APIs for a while.

[SPEAKER_00]: We've looked at even WAFs and DDoS, right?

[SPEAKER_00]: Right anomalies.

[SPEAKER_00]: You have sudden spikes in query volume, especially the sense of the systems that that suggests the agent being used as a proxy and so you need to be able to detect and block that.

[SPEAKER_00]: And then, traditional security perspective lateral movement, if you have one agent accessing credentials or contacts intended for a different agent, now you certainly have a problem and you need to be able to see that and block it pretty quickly.

[SPEAKER_01]: So you mentioned this a bit already where security teams don't want to create or limit the functionality.

[SPEAKER_01]: So we have business leaders coming back to you and be like, hey, this isn't very useful because it's completely locked down.

[SPEAKER_01]: Security teams don't want to be the bottleneck.

[SPEAKER_01]: How do organizations balance strong enforcement with the need to keep AI development and deployment moving fast as fast as innovation can move?

[SPEAKER_00]: for too often that a lot of organizations the security organization is operated kind of outside the bounds or outside the parameters that we ask developers to do.

[SPEAKER_00]: So I'd start with policy as code.

[SPEAKER_00]: Those enforcement rules can live in version control right alongside the agent code.

[SPEAKER_00]: They're reviewed in your CACD pipeline before reaching production.

[SPEAKER_00]: So take a similar approach you're taking to code with policy as well.

[SPEAKER_00]: Observe before and force, right, that crawl walk around approach, start an audit mode, understand the baseline behavior.

[SPEAKER_00]: Before writing those blocking rules, it helps avoid pulse pauses, slow development.

[SPEAKER_00]: But then you have to come back to it.

[SPEAKER_00]: You have to move to enforce.

[SPEAKER_00]: You can't just leave it in observe forever.

[SPEAKER_00]: Teared enforcement could be another one.

[SPEAKER_00]: Similar to we've done with other blocking mechanisms in the past.

[SPEAKER_00]: No, like Dev and Staging might have more permissed monitoring, whereas production has enforced policy.

[SPEAKER_00]: Same tooling in place, just the different modes.

[SPEAKER_00]: And then developer self service, I believe being able to allow teams to see their own agents behavioral profile, understand what it will block before they deploy, because one of the things that I think kills developer velocity and we've seen this over and over right is an enforcement.

[SPEAKER_00]: But it's enforcement that nobody understands.

[SPEAKER_00]: As a CSO and security professional, us all this too often, security blocks or flags things, but don't give that feedback back to the developers.

[SPEAKER_00]: So the insight as to when and how and why.

[SPEAKER_00]: And with that rule blocks your agent, you have no idea why you file a ticket, you wait you're frustrated, but if you can look at that dashboard that shows, hey, here's what your agent did in staging, here's which of those calls would have been blocked in production, here's why.

[SPEAKER_00]: That's actually a developer accelerant.

[SPEAKER_00]: All right, they catch issues before deployment, security team isn't the bottleneck or reactive after it's in prod,

[SPEAKER_00]: And so the shift really then is from security as the team that says no at the end to security is the team that gives you the signal you need to be able to ship that code faster with confidence.

[SPEAKER_01]: It really turns traditional stereotypes of security on its head and really enables.

[SPEAKER_01]: things to move fast and be secure, which is incredibly important and really exciting, honestly, when you think about it.

[SPEAKER_01]: Okay, I got one more question.

[SPEAKER_01]: When organizations have the ability to discover, observe, and enforce AI behavior in real time, which you are illustrating is so important.

[SPEAKER_01]: How does that change accountability at the enterprise level?

[SPEAKER_01]: What does good governance look like from there?

[SPEAKER_00]: You see this in modern EGRC tools.

[SPEAKER_00]: You see this in modern security programs, right?

[SPEAKER_00]: Governance becomes evidence-based rather than attestation-based.

[SPEAKER_00]: It's not just a check mark once a year, once every three years.

[SPEAKER_00]: When you just roll it out, you're not just asking, do you have a policy?

[SPEAKER_00]: You're producing logs and evidence that show the policy was actually enforced.

[SPEAKER_00]: So that accountability then, though it gets tied to specific AI sessions, specific agent identities, specific tool calls, not just hey, we use this model and those audit artifacts now are continuous, not a point in time when a border regulator asks you pull the timeline, not just a self assessment from six months ago.

[SPEAKER_00]: It's also now limit the impact if there is an actual security event, right?

[SPEAKER_00]: A story of her in the past is once you have that actual outestation based, even if you do have an incident, you can say how it was limited, how it was contained, right?

[SPEAKER_00]: Those notifications don't have to go to all 5 million 10 million customers.

[SPEAKER_00]: You can say, hey, these five customers were impacted.

[SPEAKER_00]: So fewer notifications, lesser fines, even if there is an incident because you have that out of station in that limit.

[SPEAKER_00]: And so then risk quantification becomes possible.

[SPEAKER_00]: You can say this agent access this data 4,000 times in Q2.

[SPEAKER_00]: Every access within policy rather than hey, we think our controls are good.

[SPEAKER_00]: And so fundamentally, that changes the thing that changes most for the CISO is the conversation with the board.

[SPEAKER_00]: Right now, the board asks, how do we know our AS systems are behaving appropriately?

[SPEAKER_00]: The audit and stance are for most organization is, hey, we reviewed the design, we approve the deployment, we have a policy doc.

[SPEAKER_00]: That's after station, right?

[SPEAKER_00]: That's not evidence.

[SPEAKER_00]: What government looks like when you have a closed control loop is I can pull a time frame of every action that eight that every agent took, every tool it called, every piece of data it touched.

[SPEAKER_00]: And I can show you exactly where policy was enforced and where it wasn't.

[SPEAKER_00]: So that's fundamentally a different conversation, and that's what moves AI security for a framework exercise to an operational capability.

[SPEAKER_00]: So these, like to say, those good runtime controls enable broader AI adoption, not restricting it.

[SPEAKER_00]: And this reframe lands well as he's so tired of being seen as blockers, and security becomes the foundation, not the ceiling.

[SPEAKER_01]: Absolutely, Craig, that just makes too much sense.

[SPEAKER_01]: I really appreciate you returning to the show today.

[SPEAKER_01]: It's clear that businesses have to move to runtime containment.

[SPEAKER_01]: I think we have nailed that on the head today.

[SPEAKER_01]: The days of older slower models are over.

[SPEAKER_01]: See, so it's half to acknowledge this blind spot and change the way they think about their operation.

[SPEAKER_01]: You have to catch these issues fast and lower the blast radius.

[SPEAKER_01]: And in doing so, you actually maintain speed and innovation rather than handwritten.

[SPEAKER_01]: Enterprises can move this to an operational capability through these runtime controls.

[SPEAKER_01]: I think you've made that very clear Craig really appreciate you coming back to the show and telling us what's missing in AI security today.

[SPEAKER_00]: Thanks, Nellig.

[SPEAKER_01]: It was great to have Craig back on the show to point out what's missing in AI security today.

[SPEAKER_01]: And that is changing the models of security away from reactive to proactive at runtime.

[SPEAKER_01]: If you'd like to learn more about Walarm, you can visit Walarm.com, that's W-A-L-L-A-R-M.com.

[SPEAKER_01]: And thanks again for listening.

Latest Season of the Podcast is Sponsored By