TL;DR - Microsoft Threat Intelligence published the research on 5 November 2026, and the r/netsec thread at 119 points is what brought it to attention this week. An agentic AI offensive framework has been scanning public GitHub for exposed secrets since August 2026. A stolen secret signs in as an Entra ID service principal, then requests ARM, Key Vault and Graph, Storage or Cognitive Services tokens, often within seconds. In one observed case the path from a GitHub search to Key Vault exfiltration took five minutes, and a single-tenant OAuth application's token was used to enumerate other cloud resources. What you need to do: export every service principal with a client secret and its expiry, scope down the broadest role assignments, move one identity onto workload identity federation this week, and alert on unusual token request sequences.
By The Numbers
| Figure | Value |
|---|---|
| Microsoft Threat Intelligence report published | 5 November 2026 |
| r/netsec thread that resurfaced it | 119 points, this week |
| Automated scanning running since | August 2026 |
| Fastest observed path, GitHub search to Key Vault exfiltration | five minutes |
| Token types requested in sequence | ARM, Key Vault, then Graph, Storage and Cognitive Services |
| Secrets targeted in public repositories | app client secrets, OAuth credentials, storage account keys, AI inference API keys |
| Controls Microsoft recommends | five, all of them preventive or detective at the identity layer |
I have spent the last two weeks telling clients that their agent problem lives in the identity the agent runs as, and this week's story is the cleanest evidence I could have asked for. A secret sitting in a public GitHub repository became Key Vault data in five minutes, with no human in the loop at any point.
The research is not brand new. Microsoft Threat Intelligence published it on 5 November 2026, and I want to be straight about the date because a lot of coverage this week has implied it landed in the last few days. What landed this week is the r/netsec thread, which hit the front page at 119 points and put the story in front of the audience that needed to read it. The gap between publication and attention is its own small lesson, and I will come back to it.
My interest is in the question those five minutes ask about your tenant: what can your service principals already reach, and how long would it take somebody with one stolen secret to walk the same path through your subscription? That question has an answer today, and most organisations I work with would not like theirs.
Let me walk you through what the framework did, why the speed changes the control set entirely, and the audit I would run this week in the order I would run it.
What the framework actually did
Microsoft describes it as an agentic AI offensive framework. Secondary reporting gave it the name ARTEX, and I will use that because "agentic AI offensive framework" is a mouthful, but the naming is not the point and Microsoft did not use it.
The activity has been running since August 2026. At the scanning end it is unglamorous: automated, continuous searching of public GitHub repositories for exposed secrets. Application client secrets, OAuth credentials, storage account keys, AI inference API keys. That is the same class of exposure the secret-scanning industry has been shouting about for years, and the volume of it in public repositories is the reason this works at all.
The interesting part is what happens after a hit. The stolen secret is used to sign in as an Entra ID service principal, which is the workload identity behind an application registration. From there the framework requests an ARM token, then a Key Vault token, then Graph, Storage and Cognitive Services tokens. Often within seconds of each other. It enumerates what the identity can reach, then exfiltrates from Key Vault, Storage and the AI services.
In one observed case, the whole path from a GitHub search to Key Vault exfiltration took five minutes.
There is a second technique in the report that deserves its own line. The agents obtained a token for a single-tenant OAuth application in the target organisation, and used that token to enumerate other cloud resources. A single-tenant app is the thing people deploy when they want to be conservative, so the fact that it was the pivot is worth sitting with.
Why five minutes changes the control set
Security controls divide roughly into things that stop an action and things that notice an action. When an attack takes five minutes, the second category stops being useful, because your detection has to fire, alert a human, that human has to understand it, and somebody has to make a decision inside the same five minutes. That is not a realistic bar for a small IT team at 2am.
So the entire control set shifts to prevention, and prevention for this attack path is identity hygiene. Specifically: does the identity need standing access at all, and does the credential it holds need to exist?
That is a different conversation from "AI agents are dangerous", which is the conversation a lot of coverage defaults to. The framework here is not doing anything clever with the model. It is a scanning loop and an identity pivot, and the identity pivot is the part that would work identically against a service principal created by a developer in 2023 for a script nobody has run since.
Three published pieces of the last month cover the adjacent ground. The tv-season deletion post was about an agent with too much permission doing damage by accident. The OpenShell sandboxing piece was about containing what an agent can touch at runtime. This one is about the credential and the identity, which sits underneath both, and it is the layer where a five-minute attack either works or does not.
The five minutes, mapped onto your tenant
Let me translate the chain into the questions you would actually ask.
GitHub search. Somebody finds a client secret in a public repository. The Microsoft report says public repositories, and that is worth emphasising, because the reflex response I hear is "our repos are private". A private repository is one misconfigured fork, one archived-and-flipped setting, or one vendored copy away from public. If a secret has ever been committed anywhere, treat it as public and act accordingly.
Sign in as the service principal. A client secret plus an application ID plus a tenant ID is a complete login. There is no MFA prompt, no Conditional Access policy in the default configuration, and no human reviewing it. This is the single biggest asymmetry in the whole story. A human account with a stolen password meets MFA. A service principal with a stolen secret meets nothing, unless somebody has specifically configured it to.
Request the token chain. ARM, Key Vault, Graph, Storage, Cognitive Services. Each token is a separate audience, and each one is granted because the identity has a role assignment that permits it. If a service principal holds Contributor at subscription scope, every token in that list is available.
Enumerate and exfiltrate. Read the Key Vault secrets, pull the storage blobs, call the AI services. There is nothing exotic here. It is the same access a legitimate automation would use, which is exactly why it does not look unusual in logs unless somebody is looking for the pattern.
The path does not require a vulnerability. It requires an identity that has more access than the job needs, holding a credential that never expires because nobody set an expiry.
The audit, in the order I would run it
1. List every app registration and enterprise application with a credential, and its expiry. In Entra ID, this is the app registrations blade plus the enterprise applications view, and the field that matters is the credential expiry date. Anything with a secret expiring in 2027 or never is a standing credential that could be in a repository somewhere. I have found secrets with a five-year expiry set because the person did not want to be bothered again, which is the same decision as leaving a key under the mat and hoping.
2. For each one, write down what it can actually reach. Role assignments at subscription, resource group and resource scope. Key Vault access policies and Key Vault RBAC role assignments. Storage account keys and SAS tokens. Cognitive Services keys. This step is boring and it is the whole audit, because the report's chain is only possible where an identity can reach all of it under one credential.
3. Find where each secret lives. Environment variables on a build agent, a config file on a developer laptop, a GitHub Actions secret, a pipeline variable group, a wiki page somebody pasted into during an incident in 2024. A secret that only ever existed in the portal is a different risk from a secret that was pasted into a chat channel. Both are risks and they need different fixes.
4. Check your own repository history, not just the current tree. Every organisation I have run this against has at least one live credential in git history. Current-tree scanning misses it by definition. If you find one, the fix is rotation, not history rewriting, because rewriting history does not un-leak anything.
5. Turn on GitHub secret scanning and push protection, and mean it. Microsoft recommends both, and they are the cheapest controls available. Push protection blocks the commit at the moment somebody tries to push a recognised secret pattern. It cannot help with what is already there and it does not recognise every shape, but it stops the flow of new ones, which is the difference between a problem and a growing problem.
6. Move every service principal you can onto workload identity federation. A federated credential has no secret to steal. There is no client secret in the repository because there is no client secret at all. This is the highest-value change on the list and the one that needs actual work, because each app needs its trust relationship configured properly and tested. For the ones that cannot move this week, set a short expiry and a rotation owner.
7. Remove standing access. If a service principal holds Contributor at subscription scope because it was the quickest way to make a pipeline work in 2023, narrow it to the resource group it touches and the role it needs. Then use just-in-time elevation for the rare cases that need more. Standing access is the reason five minutes is enough time to do damage.
8. Apply Conditional Access to workload identities, or at least know where you stand. Microsoft recommends it in the report, and it is the mechanism that lets you enforce conditions on a token request from a service principal the way you would for a user. If you have never looked at this, that is a reasonable outcome for the week: know the gap exists and put it in the plan.
9. Alert on anomalous token request patterns. The pattern to look for is unusual, not the single request. One identity requesting an ARM token and then a Key Vault token and then a Graph token inside a few seconds, from a location it has never used, is the shape of this attack. A single token request is normal. The sequence is not.
10. Give the answer to somebody who is not you. The audit produces a list. That list needs an owner in the business who understands at least one line of it, because a service principal with subscription-level access whose purpose nobody can explain is a finding that needs a decision, not a ticket.
Why this could be good
There is a genuinely encouraging reading of this report and I do not want to skip it.
The attack is only possible because of standing access and long-lived secrets, and both of those are choices your organisation made. That means the fix is available to you without waiting for a vendor patch, without a product purchase, and without replacing any tooling. Workload identity federation, narrower role assignments, shorter credential lifetimes and Conditional Access on workload identities are all things you can do in your own tenant this month.
Compare it with a memory corruption bug in a runtime you do not control. There, your only lever is patch speed. Here, your lever is design, and design is something a small team can actually change.
The second encouraging thing is that Microsoft is publishing this at all. Workload identity attacks are unglamorous and they do not generate the same attention as a browser zero-day, which is precisely why the details matter. A report that names the token sequence gives a defender something to build a detection around.
And the third: the controls overlap. Almost everything on the audit list also reduces the blast radius of an agent making a mistake on its own, which is the more common failure in my experience. You are not doing this work twice.
Where this is genuinely concerning
Five minutes is faster than any human process you have. I have said this already and it deserves repeating, because it invalidates a control category. If your incident response plan assumes somebody notices and reacts, that plan does not apply to this attack. The only thing that stops it is the permission not being there.
Agents make the identity problem worse by making it faster to create identities. Wiring a coding agent to a subscription takes minutes. Creating a service principal with a client secret takes minutes. The path of least resistance for a developer who needs the agent to work is a secret with broad permissions, and nothing in the tooling nudges them the other way. This is how estates accumulate hundreds of service principals nobody can explain.
Single-tenant OAuth apps were supposed to be the conservative option. Using a token from a single-tenant application to enumerate other cloud resources is the part of the report I find most uncomfortable, because the mental model most administrators carry is that tenant isolation is a meaningful boundary. It is a boundary for who can sign in. It is not a boundary on what a token can then reach.
The eleven-day gap between publication and attention. The report went out on 5 November. The thread that made people read it hit the front page this week. Nobody was hiding anything. There is simply more security publishing than there is security reading, and the things that get read are the things with a dramatic number in the headline. Five minutes is a dramatic number, and it still took eleven days.
Key Vault is the destination, not the problem. People read this story and conclude that Key Vault is exposed. Key Vault behaved correctly. It issued a token to an identity that had permission, which is its job. The problem is upstream, in an identity with too much reach and a credential with no expiry.
What to do right now
- Export the list of app registrations with client secrets and their expiry dates. Sort by expiry, look at the ones expiring next year or later, and mark them for rotation or removal.
- Pick the three service principals with the broadest role assignments and write one sentence each on what they are for. If you cannot write the sentence, that is a finding to escalate this week.
- Search your repository history for credentials, not just the current tree. Use GitHub secret scanning, or your own pattern search over the full history. Rotate anything you find at the provider.
- Turn on secret scanning and push protection for every repository, public and private. It takes minutes and it stops the flow of new exposures.
- Move one service principal onto workload identity federation this week. One, done properly and tested, teaches you the pattern for the rest. If you can only do one thing from this list, do this one.
- Shrink one subscription-scope Contributor assignment to resource group scope. Check the pipeline still works afterwards, because the fact that it breaks is the point: it was using access it did not need.
- Write the detection rule you wish you had. One identity, multiple token audiences within seconds, or a token request from a location with no history. Even as a documented intention, it moves the conversation from theory to a ticket.
Key Takeaways
- Microsoft published the research on 5 November 2026. The r/netsec thread at 119 points is what brought it to attention this week, not the publication date.
- The framework has been scanning public GitHub for exposed secrets since August 2026, targeting app client secrets, OAuth credentials, storage account keys and AI inference API keys.
- The chain is secret, service principal sign-in, then ARM, Key Vault and Graph or Storage or Cognitive Services tokens, often within seconds.
- GitHub search to Key Vault exfiltration took five minutes in one observed case, which is faster than any human detection and response process.
- A single-tenant OAuth application's token was used to enumerate other cloud resources, so tenant isolation is not a boundary on what a token can reach.
- The attack needs no vulnerability. It needs standing access and a long-lived credential, both of which are choices in your tenant.
- The fixes are all identity controls you can apply yourself: workload identity federation, narrower roles, short credential lifetimes, Conditional Access on workload identities, and alerting on token sequences.
FAQ
What is ARTEX? It is the name secondary reporting gave to the agentic AI offensive framework Microsoft Threat Intelligence described in its 5 November 2026 report. Microsoft did not use that name itself.
Does this mean AI agents are attacking my cloud? The framework is automated and AI-assisted, and the mechanism is ordinary identity abuse. A stolen service principal secret used to request tokens would work the same way without any AI involved. The AI part makes the scanning and the pivoting faster and cheaper, which is why the five-minute figure matters.
What is a service principal, in plain terms? It is the identity an application or automation uses to sign in to your tenant, as opposed to a human user. It authenticates with a secret or a certificate rather than a password and MFA prompt, which is why a stolen secret is a complete login.
How would I know if this happened to me? Look for a service principal sign-in from an unfamiliar location, followed by token requests for multiple audiences in a short window, then reads against Key Vault, Storage or Cognitive Services. The single token request rarely looks odd. The sequence does.
Is Key Vault the problem here? No. Key Vault issued tokens to an identity that had permission, which is correct behaviour. The problem is the permission being broader than the job needed and the credential being long-lived.
What does workload identity federation actually change? It removes the secret. Instead of a client secret stored somewhere, the workload presents a token from a trusted issuer, such as GitHub Actions, and Entra ID exchanges it. There is nothing in the repository to steal, and nothing to forget to rotate.
We use private repositories. Are we exposed? Less directly, and not safely. Private repositories become public through forks, archived settings, vendored copies and mistakes. If a secret has ever been committed, treat it as exposed and rotate it.
What is the single highest-value change? Move service principals off client secrets and onto workload identity federation, starting with the ones that hold the broadest role assignments. It removes the credential the whole attack chain depends on.
My Take
The thing that makes this story land for me is not the five minutes. It is that the attack is entirely made of things we did to ourselves for convenience.
A secret with a long expiry because rotation is annoying. A Contributor assignment at subscription scope because scoping it properly would have taken an afternoon. A service principal nobody can explain because the person who created it left. An agent wired to a subscription in ten minutes because the demo worked and the permissions were the easy part.
None of that is malice or incompetence. It is the ordinary accumulation of shortcuts in an environment where the shortcuts do not hurt until somebody finds them. The framework in this report is just the thing that finds them, and it finds them at machine speed, continuously, across every public repository in the world.
So the audit I would run this week is not really about AI. It is the question I should be able to answer about any tenant I am responsible for: what can each of these identities reach, and what would a stranger with one stolen secret be able to do with it in five minutes? If the honest answer is "quite a lot", the work is identifiable and it is available to you now.
The five minutes is the number that gets the meeting booked. The standing access is the thing to fix afterwards.
Mathew Clark Founder, SecureInSeconds Currently: exporting a list of service principals that nobody can explain Drafted with AI assistance - read, verified, and fixed by a human.
Further Reading
- Microsoft Security Blog: the agentic AI offensive framework, 5 November 2026 - the original research, including the token sequence and the five-minute case
- Microsoft Entra workload identity federation documentation - how to remove the client secret entirely
- GitHub secret scanning and push protection - the scanning controls Microsoft recommends, and how to enable them across an organisation
- Cloudanix on the ARTEX findings and Aviatrix's analysis - two independent reads on the identity path
- What an AI agent did to my TV season, and why least privilege matters - the accident version of the same permission problem
- NVIDIA OpenShell and AI agent sandboxing - containing what the agent can touch at runtime, which is the layer above this one
- Managing AI token consumption - the other thing that gets out of hand when nobody owns the identity
- Postman quietly installed itself into other apps - what credentials end up where when tooling acts on your behalf



