With all the recent news about AI agent security, I wanted to go straight to the front lines and talk with someone who’s living it everyday.
I spoke with Sreenath Kurupati, co-founder and CTO of Straiker, to hear his perspective about multiple topics based on the work his company is doing with frontier AI labs and large enterprise customers.
Straiker’s platform covers discovery, agent red-teaming, and runtime security. They see the full spectrum of agent security first hand.
I learned a lot from this discussion, and I hope you enjoy it as much as I did.
Note: This interview has been lightly edited for clarity.
Recent agent security incidents
Cole Grolmus: You work with frontier AI labs to red team agents. Were you surprised by the recent incidents with agents breaking out of their environments, or were they a predictable result of how the tests were set up?
Sreenath Kurupati: I wasn't entirely surprised. Some of these incidents exposed fairly basic gaps in security engineering. While the agents demonstrated impressive capabilities, parts of what happened were preventable.
I'd break it into three pieces.
First, when you give an agent or a swarm of agents a task, you need to be very clear about the objective and its boundaries. In these cases, agents were asked to solve CTF challenges. If you give an agent a goal without clearly defining what's in scope, it's going to find ways to accomplish that goal, potentially in ways you didn't anticipate.
That doesn't mean the agent's behavior was necessarily appropriate. It means the task design created incentives for unintended behavior.
Second, you need controls and monitoring to ensure agents don't cross those boundaries. Across these incidents, there appear to have been gaps in both. You need to be able to detect when an agent is doing something outside its intended scope and intervene before it causes damage.
Third, you need proper sandboxing and isolation. A sandbox should enforce restrictions on what an agent can access, including network resources and external systems. In the Hugging Face incident, for example, the agents exploited infrastructure that had permitted network access to reach systems they were never supposed to touch.
The broader lesson is that you can't rely on telling an agent what it can and can't do. You need independent, deterministic controls that enforce those boundaries regardless of what the agent decides to do.
It's the combination of clear task boundaries, monitoring, and strong technical isolation that makes these systems safe.
Cole Grolmus: When Straiker runs a red team test, how much of the environment do you test? Are you checking the test setup as well as the agent? What monitoring do you put in place?
Sreenath Kurupati: We do a combination of both. A customer may say, “I want to prevent X, Y, and Z, and the agent should only be allowed to do this.” We look at both the agent's behavior and the controls in the environment that are supposed to enforce those boundaries.
The important thing is that you can't rely on the agent alone to respect those restrictions.
We published a blog about Heimdall, our own sandbox environment for high-risk agent testing. The concept is simple: environment isolation, permissions, and network access should be controlled by deterministic software outside the agent's control.
Monitoring is equally important. You need visibility into what the agent is doing, including its network activity, tool usage, and attempts to access resources outside its permitted scope. And that monitoring needs to be independent of the agent, so the agent can't tamper with it.
For example, telling an agent, “Don't access the network,” isn't a security control. If you really want to prevent network access, that needs to be a hard restriction enforced by the environment.
The key principle is that the agent shouldn't be able to override the controls designed to contain it.
Cole Grolmus: Some people would counter that even in a deterministic environment, the agent might find a way to hack its way out. How do you think about that possibility?
Sreenath Kurupati: If an agent finds a genuine zero-day and uses it to escape, that's a very different situation from a sandbox that was misconfigured or left open. You can't eliminate every zero-day. That's the nature of software security.
As models get more powerful, I think agents will discover more software vulnerabilities over the next year or two. We may eventually see diminishing returns as the easier vulnerabilities get discovered and fixed, especially as agents themselves become more widely used for security testing.
But if the counterargument is that an agent could still find a zero-day, that doesn't excuse missing basic security controls. You still need proper isolation, restricted permissions, and independent monitoring.
In some of these incidents, agents were able to operate and cross security boundaries for extended periods before being detected. That's where monitoring should have made a difference.
The broader point is that you shouldn't rely on any single layer of protection. Clear instructions define what the agent is supposed to do. Sandboxing and deterministic controls restrict what it can actually do. And monitoring helps you detect and respond when something goes wrong.
None of these layers is perfect on its own. That's why you need all three.
Testing agents
Cole Grolmus: When you're running a test, do you need to handle the agents with kid gloves? Should you be very specific and careful about the task, or do you intentionally create scenarios where they could go out of bounds?
Sreenath Kurupati: We do both. We cover the spectrum. Sometimes we give an agent very specific instructions through a rigid system prompt and test whether it follows them. Other times, we deliberately give it more freedom to see how far it will go.
But even when we're pushing the agent, the surrounding software environment needs to enforce hard boundaries. That's where systems like Heimdall come in.
Take a simple example. If an agent should be allowed to read from a database but not write to it, that restriction should be enforced through database permissions, not just an instruction telling the agent not to write.
We work with frontier labs, and some of our projects are client-directed. A lab may ask us to evaluate an agent under very specific conditions, while other projects are designed to push the boundaries of what agents can do.
One customer recently asked us to run an "overeager" benchmark. The idea is interesting: the agent believes it's doing the right thing, but in trying too hard to accomplish its goal, it takes actions that cause harm.
We give the agent a task, sometimes with fairly open-ended instructions, and observe how it approaches the problem. We've seen agents discover and exploit vulnerabilities in software systems to accomplish their objectives.
And that's an important risk. An agent doesn't have to be malicious to cause harm. It may genuinely be trying to help, but take actions that the user never intended or authorized.
That's why we test both whether agents respect their instructions and what happens when they don't.
Cole Grolmus: That's the point of testing: to find out what will happen in the real world. We can't dial back every test because we're worried about what the agent might do. We need to push it in a setting where we have reasonable assurance we'll catch something that goes wrong.
Sreenath Kurupati: Yes. People in the wild are going to try these things anyway. We might as well find the boundaries first.
Sandboxing
Cole Grolmus: Sandboxing has been widely debated recently, partly because of the failures in recent examples. Do you see it as an effective primary control when done properly, or are they really overrated?
Sreenath Kurupati: I think sandboxing is an effective control when done properly. But there's an important distinction between sandboxing an agent during testing and securing an agent that's actually doing work in production.
If you're testing an agent, you can build a tightly controlled sandbox environment. Some of the recent incidents exposed gaps in how those environments were designed and configured, where agents had access they shouldn't have had. Leaving aside the zero-day question from earlier, you can build strong isolation around a test environment.
But eventually, you want the agent to do real work. And the real world isn't fully sandboxed. The agent needs access to real systems, data, and tools. That's where the harder problem starts.
Even if the agent itself is running inside a sandbox, it may have legitimate permissions to take actions outside that sandbox. And those actions can still cause harm.
So sandboxing is an important control, but it isn't sufficient on its own. Testing helps you understand what an agent is capable of and where things might go wrong. But when that agent is running in production with real permissions, the risks are different and the consequences can be much harder to contain.
Cole Grolmus: Does Straiker do all of its red teaming in sandboxes, or do you test in other environments too?
Sreenath Kurupati: Both. We use different levels of isolation depending on what we're testing. One level is completely air-gapped. Another might allow access to specific network resources or databases, but with restrictions on what the agent can do.
In a lot of red teaming, we don't use a fully isolated environment. Instead, we control which actions the agent can take and monitor what happens.
For example, the environment might allow an agent to read from a database but not modify or delete anything. Those restrictions need to be enforced by the software around the agent. We don't expect the agent to enforce them on itself.
Customers sometimes give us access to staging environments and ask us to push the agents much further. These are environments where we can test more aggressively without affecting production systems or real customer data.
We've done that and found some interesting vulnerabilities without putting their customers at risk.
AI kill switches
Cole Grolmus: Kill switches are another big topic Straiker has spent a lot of time on. You were even involved in discussions with elected officials about them.
What did you take from that experience, and how do you think about the government proposal compared to Straiker's approach?
Sreenath Kurupati: Governments often get pushback when they try to regulate technology. One concern is giving the government too much control. Another is that the rules won't be effective and will just add red tape.
In this case, I think the discussion is a net positive. AI is changing rapidly, and there's very little regulation. At least the proposal puts oversight and control into the public discussion.
The lawmakers seem to be starting with a narrower set of tasks, focused on large frontier-model providers. It's an initial step, not a way to control every AI system. Even if the phrase 'kill switch' sounds broad, the first practical controls would be much narrower.
We should distinguish between a government trying to act on a frontier-model provider and an enterprise stopping activity in systems it owns.
Straiker's kill switch has the same underlying idea: if something very bad happens, you should be able to turn off the system. But the use case is different. We help a company control its own agents and stop them when it doesn't know exactly what's happening. The philosophy is similar, but the implementation isn't.
Cole Grolmus: “Kill switch” is easy to understand as a phrase and much harder to implement from a technical standpoint, especially across models and multiple agents. What's your view of how it should work technically?
Sreenath Kurupati: It's harder at the government level than at the enterprise level. If the US government wanted to stop all AI traffic, what would it mean to kill a model?
A provider could turn off a hosted model, but other people host open-weight models. Someone could have a model on a laptop. You can't control all of that. That's why I think the proposal starts with smaller steps.
For Straiker, the surface area is more defined. We work with a customer's environment. Discover AI inventories AI assets, Ascend AI red teams them, and Defend AI protects them at runtime. Discover AI can find agents a company has built on cloud platforms, and we also have an endpoint script to find what's running on employee devices.
Because we have those points of visibility, we can place guardrails and control points in the environment. A kill switch can stop traffic in the context of that company and its employees. We understand the surface area and can see the agents. That makes the control meaningful for our customers.
A universal kill switch is much harder. An enterprise can identify its own cloud deployments, its endpoints, and the traffic moving through its environment. It won't have perfect visibility, but it has places to enforce a control. No government or provider has that same control over every model someone can download and run.
Cole Grolmus: At the company level, you may not find 100% of everything, especially in a large enterprise. But you can at least find the agents you know about and stop them if needed.
You can also act at different points of control beyond just the runtime, like at the network or access controls. There are layers beyond just a “stop everything” type of kill switch.
Sreenath Kurupati: Yes. Our kill switch is the big hammer, but we have other controls for normal operations.
Straiker's guardrails look for threats such as prompt injection and remote code execution. Normally, those controls target and block specific harmful actions while people keep working.
The kill switch is a last resort when something is changing rapidly and you can't get a handle on it.
Cole Grolmus: To put it differently, you need more than one option. You might stop an entire agent, a session, or a tool call. Ideally, one system gives you all of those controls.
Sreenath Kurupati: We have those layers. At the most specific level, we monitor a prompt and the resulting tool action in flight. If that action is malicious, such as data exfiltration, and Straiker is configured to block it, we block it. We can also block the session or stop the user from taking further action.
We normally prefer the most surgical control because it has the least impact on users. If one tool action is the problem, it is better to stop that action than to turn off an entire agent.
If the behavior continues, the scope of the intervention can expand. That's different from treating every alert as a reason to use the big kill switch.
Attacks on business agents
Cole Grolmus: How much can a company rely on protections built into the model, and when does it need a separate defensive product? The models obviously keep getting better, including their ability to defend themselves, but the threats are changing too.
Sreenath Kurupati: There are two reasons you need both. First, model companies have done a good job improving safety around harmful content. It's much harder now than it was with early models to get a frontier model to produce that kind of content.
But when you put a model into an enterprise agent with tools, it lacks context. What actions are allowed in this business, this environment, and this workflow? Something can look fine to the model and still cause harm.
A separate control can understand more of the enterprise and tool context and enforce the policy. A model provider can't know every enterprise's permissions, business rules, or acceptable use of a particular tool. A generic answer from the model may be safe in one setting and unsafe in another.
Second, a company doesn't use just one model. An employee might switch from a frontier model to an open-weight model, a cheaper model, or a weaker version because of cost. You can't rely on one model provider's safeguards when many different models are in use. You need another set of guardrails across them.
Those two issues are separate. Even the best model can lack the local context, and the organization may also be running models that aren't as well protected in the first place.
Cole Grolmus: The enterprise context is important. Some trust and safety questions have broad social agreement about what’s right or wrong.
Enterprise rules are much more situational. Whether an action is allowed can depend on the company, industry, rules, and specific environment. That seems hard to account for in a model alone.
Sreenath Kurupati: It isn't realistic to pretrain for every enterprise. Each one is different. You can try to put the context into a long system prompt, but you can't pack everything in. There will be gaps.
Alignment and security
Cole Grolmus: I want to get into alignment versus security. Some AI safety people put most of their faith in aligning the models. Meanwhile, a lot of security people are skeptical that alignment will ever be enough.
I think we need both: we should continue trying to better align models, but we still need security controls. How do you see it?
Sreenath Kurupati: Let me use a human analogy. These are software systems predicting tokens, even if we use words like “reasoning” to describe them.
We don't rely only on policing and rules to make society work. Most people want to do good things. Yet there are always failures, because of a person, a situation, or the environment, and we need controls for those failures.
Models can be trained toward the right behavior. But even if the failure rate is small, at the scale of billions or trillions of interactions, there will be many failures. You need monitoring, testing, and guardrails. Alignment isn't sufficient on its own.
I wouldn't dismiss alignment either. Without it, the volume of failures would be too high. If models are trained to behave well most of the time, the security systems have fewer failures to catch. But 'most of the time' isn't enough when the systems can act at scale. We need both.
The case for security gets even stronger with open-weight models, which can be changed or trained for harmful purposes.
Abliterated and uncensored models
Cole Grolmus: That leads to another issue: open-weight models that have been abliterated or otherwise uncensored to remove safeguards, plus other models post-trained for offensive security work.
We have US frontier labs handling safety one way, other open-weight providers taking different approaches, and then people removing safeguards altogether.
It seems like the frontier labs face a lot of constraints around safety and security. Meanwhile, I’m seeing abliterated models appear all over the place recently. What do you think about this situation?
Sreenath Kurupati: It's concerning. One limiting factor is that most people won't use that last class of models. Even if people like us see a lot of them, their share of overall usage may stay small.
But a small percentage can still be meaningful at scale. Nation-states and fraudsters have incentives to use them, and we'll have to monitor that activity.
I expect most usage to remain with frontier-class models. That helps, but it doesn't give us a way to control every other model. Fraudsters will use what works for them.
That doesn't mean every business will adopt abliterated models. It means defenders still have to account for those models in the threat landscape, even if most ordinary usage stays with the frontier providers.
Cole Grolmus: Regulation might deter some activity, but it won't eliminate access to those models.
Sreenath Kurupati: Exactly.
Personal agents
Cole Grolmus: What about personal agents? People are already using them to interact with businesses, and employees may start using them at work. How do you think about the risks on both sides?
Sreenath Kurupati: There are several angles. Individuals can harm themselves with a personal agent. An agent can also cause problems for a company when many customers use them to interact with its systems.
For enterprise employees, I think many large companies will initially ban personal agents on work devices. Straiker can help them detect that use and enforce a block. That's the first phase.
It's a fairly simple control: find the agent running on an employee's machine and stop its use if the organization hasn't approved it. It doesn't address the longer-term question of how to let employees use personal agents safely.
The second phase gets more interesting. I don't know whether it's six months or a year away, but personal agents will become more accepted for employee work.
Then the agentic harms we've discussed happen at much greater scale: one or several agents per employee device, with whatever access employees give them. The threats like prompt injection and the rest are familiar, but the volume changes.
The permissions change too. Employees may give agents access to tools and data that weren't designed for this pattern of use. At that point, a blanket deny is no longer enough. Companies will need visibility into what those agents are doing and controls over the actions they take.



