We sat down with Sattyam Jain, Tech Lead at Attri.ai, to discuss his research into MCP security and some of the problems he's encountered building AI Agents.

Sattyam analysed 2,303 public MCP configurations and found that roughly half didn't declare credentials for their remote connections. That initially looked like a pretty serious authentication problem, particularly as MCP is increasingly being used to connect AI Agents to company systems and data.
But when he went back and tested the live servers, the results were quite different. Around four in ten of the servers he could probe rejected unauthenticated requests, mostly through OAuth, while about a third accepted an initial connection. Even then, accepting a connection didn't necessarily mean somebody could access sensitive data or perform privileged actions.
His research raised some interesting questions about how we're testing MCP security, but he also shared examples from his own development work where Agents were behaving differently from what his team had intended.
The MCP configurations weren't giving the full picture
Sattyam originally developed Agent Audit Kit because he wanted to automatically check AI Agent applications for security issues during development, rather than relying on developers to manually review everything before deployment.
MCP, or Model Context Protocol, allows AI applications to connect to external tools and data. That might be a company's CRM, internal documents, databases or other business systems. As more developers started building applications with these connections, Sattyam wanted to understand whether the necessary security controls were being implemented.
He started by testing the scanner against his own repositories and was surprised by how many issues it identified.
"I got lots of issues. I was surprised," he told me.
He then started using it across projects at his company before expanding the research to public MCP configurations.
One of the main findings was how many configurations appeared to be missing authentication. But Sattyam wanted to understand whether that meant the servers were actually accessible without credentials, because his scanner was only looking at what was declared in the configuration files.
A server could still be enforcing OAuth even if the configuration didn't explicitly declare credentials, so he went back and tested the live connections.
A substantial proportion rejected unauthenticated requests, despite their configurations suggesting authentication might be missing. Others accepted an initial connection, although further testing would be needed to establish whether an unauthenticated client could access tools, retrieve information or perform actions.
Sattyam was particularly keen to clarify the distinction in the material he sent over after our interview.
"About half of the configs declare no credentials. That's not the same as half the servers having no authentication."
That makes quite a difference to how the research should be interpreted. The original scan identified configurations worth investigating, but it couldn't establish on its own whether a server was vulnerable.
For organisations assessing their own MCP environments, the findings suggest that configuration scanning is a useful starting point, but you still need to establish what the server actually allows.

His project management Agent started answering like a developer
When I asked Sattyam what he thought were the biggest security risks for organisations starting to connect AI Agents to internal systems, he talked about how much attention developers put into getting Agents connected compared with controlling what they can actually do.
He had an example from a software development application his team had been building, where multiple Agents were responsible for different parts of the development process.
They had an orchestrator managing the overall workflow, with separate Agents handling project management, development and other tasks.
During testing, they noticed that the project management Agent was producing responses that should have come from the development Agent and taking on responsibilities outside its intended role.
Sattyam explained that the problem came from how they were passing information between the Agents. Instead of giving each Agent only the information needed for its own task, they were sharing more of the conversation and work history, which caused the responsibilities to overlap.
The team changed how information was passed between Agents, introduced additional policy checks and used the orchestrator to manage interactions.
"Users should always talk to the orchestrator agent," Sattyam explained.
For their application, that meant users interacted with one Agent, which would then coordinate the others and control what information was passed between them.
This wasn't a security breach, but it was a useful example of Agents taking on responsibilities their developers hadn't intended.
Imagine a similar situation inside a bank, where different Agents are responsible for customer enquiries, account updates or payment processing. If an Agent starts acting outside its intended role, you would want to know whether the permissions it has been given would actually allow it to perform those actions.
An Agent producing the wrong response is one thing. An Agent with permission to make changes to customer records or financial systems could create a much bigger problem.
Sattyam's example doesn't demonstrate that the Agents could bypass the permissions of their underlying systems. But it does show why assigning an Agent a particular role doesn't necessarily mean it will always behave according to that role.
What happens when somebody deliberately tricks an Agent?
The problem becomes more concerning when somebody is deliberately trying to influence what an Agent does.
Sattyam has also been researching poisoned tool descriptions, where malicious instructions are placed inside the information an Agent uses to understand a tool.
When an Agent connects to a tool, there will normally be a name and description explaining what the tool does and how it should be used. Sattyam pointed out that while a person might mostly look at the tool's name, the Agent reads the description as well.
An attacker who can influence that description could potentially introduce instructions that have nothing to do with the tool's intended purpose.
He gave an example involving an Agent built to check somebody's inbox and summarise their latest emails.
An attacker tries to introduce an instruction telling the Agent to add another email address as a BCC recipient whenever it sends an email. The Agent might interpret that as a legitimate instruction and attempt to follow it, despite it having nothing to do with the original task.
Sattyam said he had explored this type of behaviour in his own applications, and his research also covers attacks involving poisoned tool descriptions.
The first thing I'd want to know in that example is why an Agent that's meant to summarise emails has permission to send them.
If the Agent only has read access to the mailbox, the malicious instruction shouldn't allow it to send anything. But if somebody has given it broader permissions to read, send and forward messages, the same instruction could have a very different outcome.
Sattyam recommends a deny-by-default approach, where Agents can only perform actions they have been explicitly permitted to carry out. He also thinks those restrictions should be enforced through policies, rather than simply adding more instructions telling an Agent what it shouldn't do.
OAuth and other authorisation mechanisms can already restrict access through scopes and policies, but those permissions still need to match what the Agent is supposed to be doing.
There are really two things to test in the email example. Does the Agent recognise that the instruction is malicious, and if it doesn't, will the permissions and security controls actually prevent it from sending the information?
The second question is particularly important because you can't assume an Agent will recognise every malicious instruction it encounters.

Every Agent needs an Identity and somebody responsible for it
The discussion around permissions also raised another issue Sattyam has been seeing, which is how organisations identify Agents and establish who is responsible for their actions.
If an Agent uses somebody's existing credentials to access an application, the resulting activity might simply appear under that person's name. You could see that a customer record had been updated without being able to tell whether the person made the change themselves or an Agent did it on their behalf.
Sattyam recommends giving Agents their own non-human identities and making somebody responsible for managing each one.
"Every agent should have an independent owner."
For an organisation deploying hundreds or potentially thousands of Agents, you would want to understand which Agents exist, who owns them, what systems they can access and whether those permissions are still needed.
There is also the question of connecting an Agent's activity back to the person who authorised the task.
If somebody asks an Agent to update a customer record, it would be useful to know which Agent made the change, who requested it and whether the action was within what had been approved.
Sattyam said one mistake he sees is developers concentrating on getting Agents authenticated through SSO, SAML or OAuth without giving the same attention to the restrictions governing what they can do afterwards.
An Agent might have its own Identity, authenticate successfully and still have far more access than its job requires.
That seems like something Identity teams should be looking at particularly closely as more Agents are deployed. It's not just about discovering all the new non-human identities appearing in the environment, but understanding which ones have broad access to sensitive systems and who is responsible for reviewing that access.
Testing what an Agent shouldn't be able to do
Towards the end of our conversation, I asked Sattyam what advice he would give to a CISO or Head of Identity who was starting to deploy AI Agents.
His first recommendation was to spend more time planning what the Agents need to do and how the architecture should work, rather than immediately starting to build everything. He also recommended looking at existing solutions before developing your own security controls and making testing a much bigger part of the process.
His own open-source projects reflect that approach. Agent Audit Kit focuses on finding security problems in code and configurations during development, while Agent Airlock is designed to check tool calls at runtime and determine whether particular actions should be allowed.
Sattyam wants these checks built into the development process so that security testing happens automatically, rather than depending on somebody remembering to run it. He also thinks organisations deploying large numbers of Agents should have common security controls that apply across applications, instead of leaving every development team to build its own approach.
He suggested using AI Agents to test other Agents, deliberately exploring unexpected behaviour and trying to find problems before deployment.
I thought that was particularly interesting given what he had found in his own application. Developers will normally test whether an Agent can complete the task it was designed to perform, but it's also important to find out what happens when it receives unexpected instructions or starts choosing different ways to complete the task.
For example, if an Agent has been built to retrieve customer information, can it be persuaded to modify that information? If it receives malicious instructions inside a document or tool description, will it try to follow them? And if it does, what security control is actually going to stop it?
There is an important difference between an Agent refusing to do something because of its instructions and a system preventing the Agent from doing it because it doesn't have the necessary permissions.
That also brings us back to Sattyam's original MCP findings. His configuration scan was useful for identifying potential problems, but testing the live servers gave him a better understanding of what was actually protected.
The same principle applies when testing an Agent. It's useful to see it completing the task it was built for, but you also need to establish what happens when it attempts something outside its responsibilities.
The biggest takeaway for me
Towards the end of our conversation, Sattyam talked about how often his research was still finding security problems in AI applications and how he wanted that to change.
"I want to be less surprised."
His point was that finding fewer problems would be a sign that developers were building more reliable applications and security was becoming a normal part of the development process.
So if I was running Identity for an organisation deploying AI Agents, there are probably three things I'd want to check:
Does every Agent have its own Identity, a clear owner and a way to establish who authorised its work?
Are we restricting what the Agent can actually do, or relying on instructions telling it what not to do?
Have we tested what happens when the Agent tries to perform an action outside its responsibilities?
I'd want the development team to demonstrate both what the Agent can do and what happens when it tries to do something it shouldn't. In particular, I'd want to see which security controls actually stop those actions.
The research is a good example of why that's worth doing. Checking how something is configured can tell you where to start looking, but testing what it actually allows is how you find out whether the security controls are working.
Research and Resources
Sattyam shared the following research and projects