AI agents are moving faster than cybersecurity can keep up. Who’s in control? – Fast Company Middle East | #hacking | #cybersecurity | #infosec | #comptia | #pentest | #ransomware

The ability to act on their own is exactly what makes agentic AI appealing to businesses. Agents can gather information, complete tasks, and move between systems with little human help. But this also raises a tough cybersecurity question: how can organizations maintain control over systems that make decisions and act as quickly as machines?
As businesses deploy more autonomous agents, security experts say they need to rethink identity, access privileges, and accountability. The challenge is no longer simply deciding who can enter a system, but understanding what an agent can do once it gets there, and how quickly an organization can stop it.
AI AGENTS WITH A NEW KIND OF IDENTITY 
Traditional identity and access management (IAM) was largely designed around people logging into systems and applications, authenticating through APIs or service accounts. AI agents complicate that model because they can operate autonomously across both environments.
“An agent might query a database, call an API, invoke another agent through an MCP server or use a graphical interface, much as a person would,” says Zachary Krider, Senior Director, AI and Agentic Engineering at Trellix. “A record showing that an authenticated identity accessed a resource no longer tells you enough about what happened.”
Security teams need to determine whether an action originated from a person, an application, or an agent acting on someone else’s behalf. They also need to know who started the agent, what tools it could use, and how much it was allowed to do.
According to Mortada Ayad, VP of Sales – META at Delinea, conventional software and employee security models do not fully account for how agents operate. With conventional software, organizations generally know which steps an application will take. Agents, however, can find different ways to achieve the same objective, potentially moving between systems before a human has time to investigate an alert.
“We saw the stakes when autonomous agents targeting Hugging Face compromised production clusters across multi-region environments over a few days,” Ayad says. “That is why I would govern agents as a distinct kind of identity. They have room to act independently, and they act at machine speed.”
James Maude, Field CTO at BeyondTrust, sees agentic AI as part of a wider non-human identity problem rather than an entirely separate cybersecurity discipline.
“Agentic AI is a subset of the non-human identity problem, and the discipline that governs it already exists: privilege management,” he says. “When it comes to how to manage AI, the actor has changed, but the job has not.”
This means removing standing privileges across human, machine and AI identities rather than creating an entirely separate security framework for agents.
THE PROBLEM WITH TOO MUCH ACCESS
One of the biggest risks emerges when organizations give agents more permissions than their tasks require.
An agent may operate under an employee’s identity, share a service account with other applications, or retain credentials long after a task has ended. This can make it difficult for security teams to distinguish its activity from that of other users and applications.
Krider says every agent should have a unique identity, from development through to production. That allows organizations to trace which agent accessed a system, what it did and which resources it touched.
“Permissions should be tightly scoped to the agent’s purpose, and credentials should be short-lived where possible,” he says.
Ayad says the issue isn’t always a lack of understanding of least-privilege security, which means giving only the access needed. Instead, operational pressures can make giving broader access seem like the easier choice.
He points to power plants and critical infrastructure facilities, where teams prioritize keeping systems running. If following the approved access process delays a repair, employees might look for shortcuts. Giving an agent a broad account to get the job done quickly can make this problem happen even faster.
Recent research from Delinea in the UAE shows a gap between having security policies and actually enforcing them. Every respondent said their organization had a policy governing the data AI tools and agents could access. Yet 98% reported a confirmed or suspected case of an AI tool accessing sensitive data beyond its assigned task, while only 59% said those policies were actively enforced.
“The practical answer is to make the right access easy to obtain and quick to end,” Ayad says. “An agent should get the permissions needed for the task in front of it, without a lengthy detour for the team using it. Otherwise, the workaround will keep winning.”
Maude says many agents launch with the full permissions of the person or service account that started them, “because that was the path of least resistance to get them working.”
“Nobody designed that access, it was set and simply never removed,” he adds, recommending finding every agent in use, mapping out what each one can access, and removing any ongoing privileges they don’t need.
LEAST PRIVILEGE GETS MORE COMPLEX
Giving an agent access only to what it needs sounds straightforward until the agent starts deciding what to do next.
Unlike conventional applications, agents can take different routes to achieve the same objective. Organizations, therefore, cannot simply approve a task at the outset and assume every action that follows will be appropriate.
Krider says companies need to assess an agent’s authority beyond conventional data permissions. That includes the APIs it can call, the tools and MCP servers it can invoke, the scripts it can execute and any permissions it inherits from the user or application that initiated it.
An agent investigating a security alert, for example, may need to query security telemetry. That does not mean it should be able to modify cloud infrastructure, delete data or turn off a security control.
“Approving a task is only the starting point. As the agent works through it, each request for access needs its own decision in the context of that task,” Ayad says.
He gives the example of an agent investigating a failed payment. Reading the relevant transaction may be appropriate, but searching an accessible SharePoint site for credentials to another system is not necessarily justified, even if the agent believes it could help solve the problem.
“That is what runtime authorization is meant to do. The agent retains the freedom to work through a problem, while the organization retains control over what it can actually reach,” Ayad adds.
Maude says organizations should not rely on an agent to recognize when it has crossed a boundary.
“An agent doesn’t see a denial of access as a signal to stop, but rather a problem to route around to achieve a goal,” he says. “This means it will exploit any misconfigurations or hidden access paths to achieve a result that you might not want.”
The question is not which tasks an organization can anticipate, but which actions, resources and credentials an agent should be able to use.
“The agent can be as creative as it likes inside the box, but you need to decide what size that box is,” Maude says.
A VALID LOGIN IS NOT A GUARANTEE
The more difficult cybersecurity scenario is not necessarily an agent trying to access something it has been explicitly forbidden from accessing. It is an agent that has legitimate permissions but begins using them for the wrong reasons.
A compromised agent may continue passing conventional access checks because its credentials remain valid. That makes detection more complicated.
“A valid credential is not proof that an agent is behaving as intended,” Krider says. “If an agent is manipulated or compromised, it may carry out actions that pass an access check but fall well outside the purpose for which that access was granted.”
Security teams therefore need visibility into the entire execution chain: what initiated the agent, what information it received, which tools it invoked and what data it accessed.
Krider says these records become more useful when correlated with identity, network, endpoint and data security events. An agent suddenly accessing an unfamiliar database, invoking an unusual tool or transferring large volumes of data should prompt investigation.
According to Ayad, access decisions must also be reassessed throughout an agent’s session, particularly because the instructions guiding it can change after its initial authorization.
“The truth is that a compromised agent only uses permissions it legitimately has,” he says. “That actually makes this case difficult because the login succeeds and the resources may sit within its approved access, while its actions no longer serve the task.”
An agent assigned to summarize support cases, for instance, should not be able to export an entire customer database simply because its account has access to it.
Maude argues that this is where organizations relying too heavily on detection-based security run into trouble.
“A hijacked agent is not acting suspiciously; it is doing exactly what it is allowed to do, for the wrong reasons,” he says.
He recommends removing standing access and granting extra privileges only when needed for a specific task. For important actions, organizations should still require human approval.
“If the agent doesn’t hold the privilege, the attacker inherits nothing,” Maude says.
WHEN AN AGENT GOES WRONG, CAN YOU STOP IT?
Detecting unusual activity is only part of the response. Organizations also need to contain an agent quickly, revoke its access, and determine what it did before the incident is considered resolved.
Krider says the ability to stop an agent should be built into its architecture from the beginning. Dedicated identities let security teams  revoke credentials without taking down an entire application. They may also need to block network connections, restrict access to tools or MCP servers, or isolate the environment in which the agent operates.
Ayad says organizations should rehearse this response before an incident occurs.
“Whoever receives the alert needs a clear route to end the session, revoke its access and prevent it from starting another one,” he says. “That response should be rehearsed before an incident.”
Maude points to another complication: credentials can be scattered across hardcoded keys, inherited tokens and shared accounts, making them difficult to locate and revoke without disrupting other operations.
“Revocation needs to be quick and a policy change, not a long, slow process of hunting down access,” he says.
He recommends testing selected agents to understand how quickly security teams can establish the potential impact of their access and revoke it.
After containing an agent, the next step is to find out what happened. Krider says observability platforms can record prompts, responses, tool calls, and execution traces. Network and API gateway logs can also help track where the agent connected.
Ayad emphasizes the importance of recording every action in sequence, including the identity involved, the task being performed, the commands issued, the data accessed and the policies that allowed or blocked those actions.
The distinction between human and machine activity is particularly important.
“I would recommend including who made the decision, human or AI; what was done; and with what authority,” Ayad says.
Maude makes a similar point about accountability. A record showing that an employee deleted a database is not the same as one showing that an AI agent independently made that decision while trying to fix a bug.
“Knowing the difference is important,” he says.
Recovery requires organizations to understand the extent of the incident, address excessive permissions, rotate exposed credentials and restore affected systems. Only then can they assess whether an agent can safely return to operation.
WHAT CEOs SHOULD CONSIDER BEFORE DEPLOYMENT
For business leaders, securing agentic AI is not simply a technology team’s responsibility. It requires understanding how many agents are operating, what authority they have, and whether the organization can account for their actions.
Krider recommends starting with an inventory of deployed agents, including where they run, who owns them and what they can do. Each should have its own identity, restricted permissions and an approved set of tools and data sources.
Ayad wants executives to go further than approving access policies. They should ensure that permissions are evaluated when an agent attempts an action, establish visibility into the identities it uses and test whether security teams can terminate a session and reconstruct its activity.
Maude cautions against allowing agents to inherit full user privileges by default or treating their security as a separate discipline from the rest of enterprise identity management.
The underlying issue is whether organizations can grant that autonomy without surrendering control over the systems, data and decisions agents can influence.
As Maude puts it, the actor may have changed, but the job of managing privilege has not.

  Be in the Know. Subscribe to our Newsletters.

  Thank you for Signing Up



ABOUT THE AUTHOR
Rachel Clare McGrath Dawson is a Senior Correspondent at Fast Company Middle East. More

!function(f,b,e,v,n,t,s)
{if(f.fbq)return;n=f.fbq=function(){n.callMethod?
n.callMethod.apply(n,arguments):n.queue.push(arguments)};
if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version=’2.0′;
n.queue=[];t=b.createElement(e);t.async=!0;
t.src=v;s=b.getElementsByTagName(e)[0];
s.parentNode.insertBefore(t,s)}(window, document,’script’,
‘https://connect.facebook.net/en_US/fbevents.js’);
fbq(‘init’, ‘1168079237972651’);
fbq(‘track’, ‘PageView’);

window.fbAsyncInit = function() {
// FB JavaScript SDK configuration and setup
FB.init({
appId: ‘915130522490616’, // FB App ID
cookie: true, // enable cookies to allow the server to access the session
xfbml: true, // parse social plugins on this page
version: ‘v3.2’ // use graph api version 2.8
});
// Check whether the user already logged in
// FB.getLoginStatus(function(response) {
// if (response.status === ‘connected’) {
// //display user data
// //getFbUserData();
// }
// });
};
// Load the JavaScript SDK asynchronously
(function(d, s, id) {
var js, fjs = d.getElementsByTagName(s)[0];
if (d.getElementById(id)) return;
js = d.createElement(s);
js.id = id;
js.src = “https://connect.facebook.net/en_US/sdk.js”;
fjs.parentNode.insertBefore(js, fjs);
}(document, ‘script’, ‘facebook-jssdk’));
// Facebook login with JavaScript SDK
function fbLogin() {
FB.login(function(response) {
if (response.authResponse) {
// Get and display the user profile data
getFbUserData();
} else {
document.getElementById(‘status’).innerHTML = ‘User cancelled login or did not fully authorize.’;
}
}, {
scope: ’email’
});
}
// Fetch the user profile data from facebook
function getFbUserData() {
FB.api(‘/me’, {
locale: ‘en_US’,
fields: ‘id,first_name,last_name,email,link,gender,locale,picture’
},
function(response) {
if(response && response.email){
saveUserData(response);
}else{
var email = response.first_name+’_’+response.last_name+’@facebook.com’;
saveUserData({…response, email: email});
}
//console.log(response);
// alert(response.first_name+’ ‘+response.email);
// document.getElementById(‘fbLink’).setAttribute(“onclick”, “fbLogout()”);
// document.getElementById(‘fbLink’).innerHTML = ‘Logout from Facebook’;
// document.getElementById(‘status’).innerHTML = ‘Thanks for logging in, ‘ + response.first_name + ‘!’;
// document.getElementById(‘userData’).innerHTML = ‘Facebook Profile DetailsFB ID: ‘ + response.id + ‘Name: ‘ + response.first_name + ‘ ‘ + response.last_name + ‘Email: ‘ + response.email + ‘Gender: ‘ + response.gender + ‘FB Profile: click to view profile’;
});
}
function saveUserData(userData){
// console.log(‘userData’, userData);
jQuery.ajax({
type: ‘POST’,
url: “https://fastcompanyme.com/wp-admin/admin-ajax.php”,
dataType: “json”,
data: {’email’: userData.email, ‘first_name’: userData.first_name, ‘last_name’: userData.last_name, ‘gender’: userData.gender, ‘action’: ‘add_fb_user’},
success: function(response) {
localStorage.setItem(‘user_id’, response.user_id);
window.location.reload();
}
});
}
// Logout from facebook
function fbLogout() {
FB.logout(function() {
document.getElementById(‘fbLink’).setAttribute(“onclick”, “fbLogin()”);
document.getElementById(‘fbLink’).innerHTML = ”;
document.getElementById(‘userData’).innerHTML = ”;
document.getElementById(‘status’).innerHTML = ‘You have successfully logout from Facebook.’;
});
}
// Setup an event listener to make an API call once auth is complete
function onLinkedInLoad() {
IN.Event.on(IN, “auth”, getProfileData);
}
// Logout user
function logout(){
IN.User.logout(onLogout);
}
function onLogout(){
console.log(‘Logout successfully’);
}
// Use the API call wrapper to request the member’s basic profile data
function getProfileData() {
IN.API.Profile(“me”).fields(“first-name”, “last-name”, “email-address”,”picture-url”).result(function (data) {
var userdata = data.values[0];
var fname = userdata.firstName;
var lname = userdata.lastName;
var email = userdata.emailAddress;
var profile_photo = userdata.pictureUrl;
logout();
}).error(function (data) {
console.log(data);
});
}

——————————————————-
Click Here For The Original Source.