Third-Party AI Agents Your SSO Never Sees: Checklist

Third-party AI agents hide from SSO, so inventory is the real fix. Use this checklist to close agent security gaps before they spread.

A small business owner and an IT consultant leaning over a laptop at a cluttered workshop bench, a dusty server rack and tangled cables behind them in a back office

A thousand agents nobody put on a list

The 2026 State of Agent Security Report looked at environments containing roughly 1,280 third-party products with AI embedded in them. About 282 of those sit behind single sign-on. The remaining thousand or so are invisible to identity infrastructure by default, and the reason is not concealment. An identity stack can only govern what authenticates through it, and most of these agents never authenticate through anything. You can read the original writeup at The Hacker News (opens in new tab) if you want the full framing, but the number is the part that stays with me.

I keep a small VPS business, and the closest thing I have to this problem is a customer who installed a WordPress plugin in 2021 that quietly started making outbound API calls to a vendor after an automatic update. It had no owner in the hosting panel, no ticket, and no entry in anyone’s asset list. When it broke, he called me and asked what it was. Third-party AI agents are that plugin with a token into your CRM.

So the problem to solve is inventory, not model behavior. The agents that hurt you are the ones with no procurement record, no named human, and no scanner pointed in their direction. Model scanning assumes somebody chose a model. Prompt inspection assumes a gateway exists. Your acceptable-use policy assumes somebody made an adoption decision worth accepting. Agents inherited through a product update skip all three, which is why I stopped treating this as an AI problem and started treating it as an asset register that fell behind.

Four questions do most of the work, and they hold regardless of which vendor shipped the agent or which platform it runs on: identity, permissions, connectivity, activity. They are not exotic. They are the same questions I ask about a cron job or a service account, and that is exactly why they work. Below is how I have been applying them, plus where the tooling market is still selling answers to a different question.

Background: why third-party AI agents broke the first-party playbook

Every control I mentioned above assumes a moment in time. Model scanning needs somebody to have picked a model. Prompt inspection needs a gateway somebody deployed. An acceptable-use policy needs an adoption decision to accept in the first place. That moment is what gives a security team a review to run, a surface to instrument, and a human to put on the ticket when it goes wrong.

Agents skip the moment. The industry usually splits them into bought and built, and honestly both of those fit the old model fine. A built agent lives in your repo, so it gets scanned at build time and gated before merge. A bought one went through procurement, which means somebody signed something, somebody owns it, and it shows up in the renewal spreadsheet next year.

There is a third category, and it is the one I keep running into: inherited agents. They arrive through a routine product update on software the company already pays for. Nobody selected them, nobody deployed them, and the release notes security actually reads rarely mention them.

Slack Code, which launched in August 2026, is the cleanest illustration I have found. You tag the agent into a conversation, it reads the shared context, writes the code, and opens the pull request. The announcement says these agents inherit Slack’s built-in security model, permissions, and admin controls “from day one, without any additional IT lift.” Read that sentence as an engineer rather than a marketer and it describes an autonomous actor with reach into GitHub and production infrastructure whose governance is a chat tool’s channel membership. A channel admin ticking a box is not a permission review. Nobody decided anything, so there was nothing to instrument.

Here is the part that makes this structural rather than a misconfiguration somebody can patch on a Tuesday afternoon. Your SSO stack governs what authenticates through it. An agent executing inside a SaaS platform, using that platform’s own service credentials, never presents a session to your identity provider. No log line lands in your SIEM under its own name. It runs as the product, and the product already has your trust. I have looked for the setting that closes this in Google Workspace and in Okta, and there is not one, because there is nothing being authenticated.

What’s happening now: third-party AI agents are the majority of adoption

The 2026 State of Agent Security Report (opens in new tab) puts the arithmetic in plain numbers: roughly 1,280 third-party products now embed AI, and about 282 of them sit behind single sign-on. Sorting agents by how they arrive explains why the gap is so wide.

Inherited agents ship inside platforms you already run, pushed in by a product update. Configured agents are your own prompts and logic running on a vendor’s runtime, model, and connectors. Built agents are open frameworks on infrastructure you own end to end. The first two account for the overwhelming majority of adoption and are growing fast, because every major application is busy becoming an agent platform. The third is the smallest and slowest, and it is the only one with a repository to scan and a build step to gate. Security teams have spent two years buying tools aimed at that smallest bucket.

The destination is the same no matter where the agent was born. An agent that starts life inside a CRM ends up reading a data warehouse and writing tickets. An agent assembled on someone’s cloud platform ends up holding OAuth tokens into Salesforce, Slack, and Drive, because that is where the work is. This is not exotic. It is the same pattern as the Zapier-style automations plenty of small teams already run, where one connection quietly gains read and write access to four other systems and everyone forgets it exists until an offboarding goes wrong. Only now the connection can decide what to do next without a human triggering it.

That has a consequence worth sitting with. The enterprise application layer has no fixed edges, so the growth rate of your agent inventory is not set by your security roadmap. It is set by your vendors’ release calendars. You can freeze your own build pipeline tomorrow and still add forty agents this quarter.

Buyers with real weight have started pushing back. Patrick Opet, global CISO at JPMorgan Chase, told the software industry in 2025 that third-party risk has to be addressed at the source, after incidents forced the bank to isolate compromised suppliers. When a buyer that size starts naming agents as a supply-chain problem, the question lands in everyone else’s vendor questionnaires within a few quarters, whether or not the tooling to answer it exists yet.

What it means in practice: four questions, asked as questions

Four questions work on any agent, whoever shipped it and whatever runtime it sits on. Ask them in this order.

Is the agent registered anywhere?

Registered means a named human owns it, an entry exists in some inventory a colleague could find, and someone could answer a support ticket about it. The tell that it is not registered is simple: ask whose agent it is and watch the room. If nobody raises a hand, it is running as whoever accepted the connection, which is often a departed employee or a service account with a password nobody has rotated.

What is it allowed to do, and is that more than it needs?

Most inherited agents arrive with OAuth scopes and roles attached at creation. Somebody clicked through a consent screen during a product trial, or the vendor requested the broadest scope available because it made their integration easier to ship. No decision was made on purpose. Put the granted scopes next to the workflow the agent is supposed to run, and the gap between them is your exposure.

What can it reach, directly and transitively?

This is the blast radius question, and you cannot answer it from the agent’s own settings page. Reach is a property of your environment, not of the agent. A CRM agent that reads a customer table and writes tickets can touch whatever those tickets trigger downstream, and any other agent watching that queue. The Hacker News write-up (opens in new tab) makes the point that this is where agent security separates from what the market currently sells, because a questionnaire or a prompt filter evaluates one agent in isolation and reach never lives in isolation.

What is it actually doing, and is that normal for what it is?

Judge by observed behavior, not by the description written in the prompt. An agent documented as summarizing support threads that spends its afternoons calling a billing endpoint outside business hours has answered the question for you, and the answer is that the prompt is a marketing document.

None of the four requires the vendor’s cooperation, which matters, because the companies shipping inherited agents are not going to hand you an inventory voluntarily.

What to expect next

The inherited category keeps growing whether or not anyone approves it. Every major application is turning into an agent platform, because that is what the vendors’ roadmaps say and because standing still looks like falling behind. That growth will not arrive as a procurement event, a ticket, or a rollout plan. It arrives as a release note you did not read, on software that was already in your stack before the agent existed. I have watched this happen with smaller things for years: a cPanel update adds a feature, nobody asks, and six months later it is running on four hundred customer accounts. The difference now is that the feature opens pull requests.

Tooling will keep arriving too, and most of it will keep answering the wrong question. Questionnaires, prompt filters, and model scanners all evaluate an agent in isolation, and isolation is not where the exposure is. Reach lives in the environment. Until vendors build something that reads connected grants across the whole application layer, a clean scan of one agent tells you that agent is well behaved, not that it is contained.

My expectation, and I want to be clear that this is a guess rather than a forecast, is that buyer pressure eventually forces disclosure. Patrick Opet named third-party supply chain as systemic risk at JPMorgan Chase, and when a buyer that size starts asking, embedded agents end up in contract terms and product documentation. That is the right outcome and I would not plan a security program around its arrival. Contract cycles are slow and the agents are already installed.

What I genuinely do not know is how agent identity management matures. It could settle into the identity provider as a new class of workload identity, it could become a function of each application platform, or it could end up somewhere that does not exist yet. Anyone telling you the answer with confidence right now is selling something. The practical position is to assume none of those options will save you this year and build the inventory yourself, because the inventory is the part you can control and the part every later decision depends on.

Start with the connected apps report, today

You do not need a new platform to begin this. Every identity provider already logs the grants you need, and the inventory exists whether or not anyone has looked at it.

Start with Google. In the Admin console, go to Security, then API controls, then App access control. That screen lists every third-party app holding an active grant against your Workspace tenant, the scopes each one carries, and which organizational units have it. Export it. Then do the same in Microsoft Entra under Enterprise applications, and in Okta under the assigned applications view. On the chat side, Slack’s app approval settings and the Manage apps page show what has been installed into the workspace, who installed it, and whether it cleared review.

Then do the boring matching work. Take the vendor names from those exports and cross them against the AI features your software shipped in the last twelve months. The CRM that added a drafting assistant, the ticketing tool that added triage, the repository host that added a coding agent. Some of those arrive as new OAuth clients with their own names. Others do not, and they ride the grant the product already had, which is worse, because the app you approved in 2023 now does more than it did when you approved it. It is the same failure mode as a contractor account you set up for one job and never closed, except nobody created a new account for you to notice.

Write down every entry with an active grant and no named human attached to it. Send the list to whoever owns the relevant system and ask one question: whose is this? Give them a week. Anything without an owner by Friday gets revoked, and you can re-grant it later if someone actually needs it. Nothing on that list is so load bearing that a week of downtime costs more than another year of an unowned agent holding tokens into your repositories and your production infrastructure.

If you only do one thing this quarter, do that export and that naming exercise. It is unglamorous, it takes an afternoon, and it is the only step on this list that gets harder the longer you wait.