79% run AI agents in production, 2% have tools built to secure them: what the gap looks like

TechScripts Nepal · Kathmandu · October 26, 2026 · 6 min read

Two surveys published in October describe the same uncomfortable picture from different angles. SailPoint's identity-security research says most large organizations already run AI agents in production, and almost none have tools built to govern them. OutSystems, working with CIO Dive and KPMG, found executives feel confident about governing agents while few say they're actually prepared for what happens when agents collide with real systems.

Before the numbers: both reports come from vendors that sell products aimed at exactly these problems, and both rely on self-reported answers from limited samples. They're best read as evidence of direction, not as precise measurements. The direction is consistent enough to take seriously.

What SailPoint found

SailPoint's fifth annual Horizons of Identity Security report, released October 6, reportedly surveyed 340 identity, IT, cybersecurity, and risk leaders at global enterprises. Its headline figures, as reported across coverage of the release:

79% of organizations run AI agents in production.
2% use identity security tools specifically designed to manage and govern them. SailPoint frames this as a 40-to-1 gap.
AI agents account for 22% of all non-human accounts, yet 85% of organizations still rely on identity tools not built for agent identities.
About 54% sit at the lowest maturity tier for agent identity controls, and only 15% can provision non-human access in real time.
Among organizations that invested in securing non-human identities, 62% reported measurable productivity gains and 46% reported safer, faster AI deployment.

One outlet reported a different headline number (4%) for organizations with a fully modern identity stack. That appears to measure something else, and the 2% figure is the report's agent-specific one.

What OutSystems found

OutSystems's research, released October 16 in collaboration with CIO Dive and KPMG, surveyed 858 executives and IT decision-makers in June 2026. Among its findings:

82% of executives believe their organizations can keep pace with governing, integrating, and monitoring AI agents as they move into production.
Only 26% say they are well prepared to resolve conflicts across agents, systems, and automated workflows.
Only 12% say agentic AI has accelerated the launch of new products, services, or customer experiences.
83% rely on existing IT, security, or compliance processes, while only 5% have automated controls, audit trails, and formal human review points.
74% cite integration with existing applications as a priority, and 81% rate testing and validating agent behavior as very or extremely important when choosing tools.

The contrast between the first and second bullets is the story: broad confidence, narrow readiness.

Why the gap is more than a statistic

It helps to translate "agent identity" into plain terms. An AI agent that reads email, files tickets, queries a database, or calls an API does so with credentials. Those credentials belong to an account, and that account is, in effect, a new employee that never sleeps, was never interviewed, and may have been created by whoever was building a prototype that quietly became production.

That's why identity vendors are loud about this. Conventional identity tools assume accounts belong to people, who join, move teams, and leave, and whose access is reviewed periodically. Agents don't follow that lifecycle. They can be created in minutes, accumulate permissions as features get added, and keep running long after the person who built them has moved on.

We've seen what goes wrong when the controls around an agent are thin. The Gemini test that reached real companies' systems, GitLab's AI Gateway sandbox escape, and the LiteLLM compromise are different failures with one thing in common: something that held credentials and had reach was trusted more than it should have been.

What to put in place first

You don't need a platform purchase to close most of this gap. These steps work at almost any scale, and the order matters.

Make a list of your agents. The most common failure isn't a sophisticated attack; it's not knowing what's running. Include prototypes, scripts using model APIs, and anything connected to production data. You can't govern what you haven't counted.
Give every agent an owner. A named person who is accountable for what it does and what it can reach, and who is notified when it changes.
Give each agent its own identity and the least access that works. Avoid sharing one broad credential among several agents or reusing a human's account. Prefer short-lived credentials over long-lived keys, and set an expiry or review date.
Log what agents do, not only that they ran. If something goes wrong, you'll need to reconstruct which actions an agent took, on which systems, with which credentials.
Put a human decision where the consequences are real. Only 5% of respondents in the OutSystems survey said they have formal human review points built in. Decide which actions (spending money, deleting data, contacting customers, changing permissions) need sign-off, and enforce it in the system rather than in a policy document.
Test behavior, not just output. Check what an agent does when it's given ambiguous instructions, malicious input, or a task it can't complete. The Hugging Face incident we described in our piece on agent regulation involved agents working around a boundary to reach a goal.

A note on reading these numbers

Surveys like these can overstate how mature "production" is. A prototype used by one team counts as production in a respondent's mind, and confidence is cheap to report. The actual security posture of a given company could be better or worse than the averages. The useful takeaway isn't "79%" or "2%" as precise facts, but the question they raise: if someone audited your agents tomorrow, could you list them, name their owners, and show what each can access?

Most organizations deploying agents are doing it with existing teams who are already stretched. Bringing in someone to build the first inventory, design the access model, and set up logging and review points, ideally an engineer who works inside your team for a few weeks rather than handing over a report, is often the fastest way to go from "we have agents" to "we know what our agents can do." That is the kind of embedded work we do through our forward-deployed engineering service at TechScripts Nepal, alongside our broader AI and data engineering work.