Into the Expanse: A Security Leader’s Guide to the Agent Frontier
Read more
Get a demo
Demo Request
Take a personalized product tour with a member of our team to see how we can help make your existing security teams and tools more effective within minutes.
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
Home
Blog

Three Characters, No Conditions: An M365 Session-Theft Intrusion That Moved at Machine Speed. Was AI Behind It?

Ophir Kelman
Updated
November 18, 2026
November 19, 2026
13 min read
Ready to Close the SaaS Security Gap?
Chat with us

In two waves of activity between late October and early November 2026, an attacker took over eight Microsoft 365 accounts at one organization. On each account they used a stolen session. Within minutes, they created an inbox rule with a one- to three-character name and no conditions, which buried or deleted every incoming email. The organization's automated response disabled the accounts within minutes of each rule appearing. On some accounts, though, the attacker had already acted, and on one, mail was read seconds after the account was disabled.

‍

The sequence moved fast: sign-in, session replay, rule creation and follow-on actions usually took minutes, and on one account the rule was in place 48 seconds after the attacker signed in. That speed, and how identical each takeover looked, made us ask whether an AI agent ran the post-access stage, like the AI-driven offensive frameworks such as ARTEX that Google Threat Intelligence Group, Wiz and Datadog recently reported [1][2][3]. We present that as a hypothesis, with the evidence for and against it and what would settle it.

‍

None of the individual pieces is new. We're writing it up because the pattern is simple, it repeats, and it's easy to miss with inbox-rule detections tuned for classic business email compromise (BEC). Below: what we saw, how to hunt for it, and what to change.

‍

TL;DR

  • What happened: Stolen sessions, likely from adversary-in-the-middle (AiTM) phishing on at least three accounts, each followed by the same kind of inbox rule, and on some accounts by bulk SharePoint sharing, a burst of sent mail or a new MFA method.
    ‍
  • The tell: Every rule had a 1–3 character name, no conditions and StopProcessingRules turned on. The names were a, c, cc, d and V, and one rule was literally named ... (three periods). The action was Delete, PermanentDelete or Move to Archive.
    ‍
  • Machine speed, and maybe AI: Rules usually appeared within about 15 minutes of the first sign-in, and one in under a minute. We have moderate confidence that the post-access stage was automated or scripted, with a human choosing targets. Whether an AI agent drove that automation is an open hypothesis that we hold with low confidence: the speed and consistency fit, but so do conventional phishing kits and scripts.
    ‍
  • Infrastructure: The attacker used several dedicated hosting addresses that we saw at this organization and nowhere else. We aren't publishing those. The two IP addresses we do publish are shared infrastructure that we also saw at other organizations (seven, and one), so treat them as low-fidelity indicators.
    ‍
  • What to do: Hunt for short-named, condition-less inbox rules near a token-anomaly detection (queries below). Require phishing-resistant MFA, and automate containment.
    ‍

What Happened

The accounts fall into two waves: three accounts on October 23 and five between November 4 and November 9, 2026. The waves don't share an IP address. What links them is the inbox rule: the same shape, appearing minutes after the attacker got in. One account in the earlier wave is a looser fit: its rule also marked mail as read, it came hours after the sign-in, and its infrastructure overlaps with no other account.
‍

This is the pattern across accounts, in relative time:

‍

StepRelative timeWhat happened (pattern across accounts)
First sign-inT+0From dedicated attacker hosting on five of the eight accounts, and from other addresses on the rest
ReplayT+0 to T+2 minOn three accounts, an anomalous-token detection, and the session used from a second IP
Inbox ruleUnder 1 min to ~T+15 minA 1–3 character rule with no conditions and a Delete, PermanentDelete or Archive action. Fastest: 48 seconds. One outlier came hours later
ActionsAround the ruleOn individual accounts: bulk SharePoint sharing or a burst of sends after the rule, and on one account a new MFA method about 8 minutes before it
Containment~2–15 min after the ruleThe organization's automated response disabled the account and revoked refresh tokens; passwords were then reset. On one account, mail was read 20 seconds after the disable
LockoutMinutes after containmentOn one account, 31 failed sign-ins in about two minutes from a VPN address

‍

How We Found It

No single alert told this story. What did was several alerts landing on the same identities close together.
‍

Reco's research team runs proactive hunts that line up alerts and events per identity, across policies and data sources. Here, the same accounts kept showing up with:
‍

  • Mailbox-rule detections. Reco's suspicious mailbox rule name detection fired on every account, alongside other inbox-rule detections.
    ‍
  • Sign-in anomalies. Impossible-travel and infrequent-country alerts added context on some accounts.
    ‍
  • Microsoft Entra ID Protection risk detections, which Reco ingests: anomalous token, Microsoft threat intelligence (investigationsThreatIntelligence) and suspicious credential addition.
    ‍

The value of the hunt was in connecting eight separate account takeovers into one intrusion and pulling out the attacker's playbook and infrastructure. That's in line with Google's guidance for highly automated intrusions: correlate identity, control-plane and data-plane events as one sequence, because static indicators won't cover much of this activity [1].
‍

Attack Analysis

Initial access: likely AiTM phishing on rented hosting

In AiTM phishing, a reverse proxy sits between the victim and the real Microsoft sign-in page. It relays the password and the MFA challenge in real time, then keeps the resulting session cookie. The victim completes real MFA, so the stolen session is fully authenticated. Microsoft has publicly documented this chain, from AiTM cookie theft to inbox rules and follow-on BEC, including follow-on fraud starting as little as five minutes after the session was stolen [4].
‍

A dedicated hosting address at MillenialHost (AS135392) made the first sign-in on three accounts in the later wave. Passive DNS shows throwaway lure domains resolving to it over the same period, and fresh ones kept appearing after the last account was contained. That suggests the host may be serving wider phishing activity beyond this one organization. The lures are mostly long, randomized names on cheap TLDs, impersonating SharePoint, SAML sign-in, Google Drive and webmail. No TLS service was visible on the address, so we couldn't fingerprint the phishing kit, which is why we call it the likely AiTM host.
‍

The data doesn't show how the lures were delivered. For the other accounts, including the whole earlier wave, the data doesn't show how the attacker got the session. On two accounts the user reported a suspicious MFA prompt, which fits push or real-time phishing as well as AiTM.
‍

The organization was also being password-sprayed. One compromised account had about 15 distinct failed sign-ins from hosting-provider IPs between October 22 and November 3, 2026, mostly with the Go-http-client/1.1 user agent, typical of spraying tools. But 4,725 identities in the same organization saw the same pattern, so this looks like broad background spraying, not targeting of these accounts. It's consistent with the spraying entry route in the ARTEX reports [2][3], but we can't tie it to the compromise: the attacker's access on that account came through a session flagged as an anomalous token.
‍

Token theft and replay

On three accounts, Entra ID raised an anomalous-token detection within about two minutes of the first sign-in, and the session was then used from a second IP. Splitting the work this way keeps the phishing host's address out of most of the mailbox activity, which makes IP-only detection less reliable. The replayed sessions appear to have used Outlook on the web.
‍

On one account, the attacker's session ran alongside the user's own, and the user had reported a suspicious MFA prompt about a minute before the attacker's first sign-in.
‍

Infrastructure

The attacker used several dedicated hosting addresses, at providers including MillenialHost and CrownCloud (AS199959). These made the first sign-in on five of the eight accounts: the likely AiTM host on three, and an operator VPS on two, where it carried out the whole takeover. Elsewhere, and for replay and mailbox actions, the attacker used other addresses, including cloud-provider ranges. In Reco's telemetry, the dedicated addresses appeared at this organization and nowhere else, so we aren't publishing them.
‍

The operator VPS appeared in a few hundred events over about an hour on a single day during the earlier wave. It did the sign-ins, rule creation and SharePoint sharing on its accounts. Public scan data shows RDP (3389), WinRM (5985) and HTTPS (443) open, with a Let's Encrypt certificate for infomhoes.top issued shortly before the activity. A freshly set-up box with remote-access ports open fits an operator workstation better than an automated relay. The address had an unrelated previous user until several months before this activity, so older activity on it shouldn't be attributed to this attacker.
‍

Two addresses are worth publishing because they are shared infrastructure, seen at more than one organization:
‍

  • 187.13.143.77 (PacketHub VPN), seen at 7 organizations in Reco's telemetry over 30 days. After one account was contained, it produced 31 failed sign-ins in about two minutes.
    ‍
  • 194.62.107.95 (Limestone Networks hosting), also seen at one other organization, on October 19. It read mail on one account 20 seconds after that account was disabled.
    ‍

Because others use them too, a hit on either is a lead, not proof of this attacker.
‍

Persistence and evasion: the condition-less inbox rule

The inbox rule is the signature of this intrusion. Every rule:
‍

  • had a junk name: a (three accounts), c, cc, d, V, and one rule literally named ... (three periods, not an abbreviation);
    ‍
  • had no conditions, so it caught every incoming message;
    ‍
  • had StopProcessingRules turned on, so no later rule could act on the mail;
    ‍
  • deleted the mail (four rules), moved it to Archive (three) or permanently deleted it (one). The rule named ... also marked mail as read.
    ‍

Because the rule catches everything, replies, bounce messages and security notifications never reach the victim, which buys the attacker time. Archive is an ordinary folder and the names look like stray keystrokes, so a quick look at the mailbox can easily miss the rule.
‍

What the attacker did with access

  • Bulk sharing. On one account, the attacker generated 355 SharePoint sharing events in under three minutes from the operator VPS. The data doesn't show who the items were shared with.
    ‍
  • Outbound mail. On another, the attacker sent nine messages in about four minutes. The last one went out three seconds before the account was disabled. We don't have recipients or subjects, so we can't say whether this was internal phishing or invoice fraud.
    ‍
  • A new MFA method. On one account, the attacker registered two new security-info methods within a minute of the replay, about eight minutes before creating the rule. Entra flagged them as a suspicious credential addition. A second factor under the attacker's control can outlive a password reset.
    ‍
  • Mail reads after the disable. On one account, mail was read from an attacker IP 20 seconds after the account was disabled and its refresh tokens revoked. Revoking refresh tokens stops new tokens being issued, but an access token already issued stays valid until it expires, by default 60 to 90 minutes after issue [5], unless Continuous Access Evaluation (CAE) applies and revokes it in near real time [6].
    ‍

None of the eight attacker rules we inspected forwarded mail. On the account we examined most closely, there were also no mailbox-level forwarding changes and no OAuth consent grants.
‍

Machine Speed: Was AI Behind It?

Google, Wiz and Datadog have each recently reported intrusions that used LLM-driven offensive frameworks, most prominently ARTEX, an AI-driven penetration-testing framework that operators point at a target and an objective [1][2][3]. We compared our case with those reports. We are not attributing this activity to any actor or tool.
‍

What points toward automation, and possibly AI

  • Speed. On the seven accounts that followed the main pattern, the rule appeared a median of about seven minutes after the attacker's first sign-in. On three accounts it took under three minutes, and on one, 48 seconds. On another of those three, the rule came 46 seconds after the session was replayed from a second IP.
    ‍
  • Consistency. The same rule shape (junk name, no conditions, StopProcessingRules, a hiding action) appeared on all eight accounts, across both waves and 17 days, from different infrastructure.
    ‍
  • Scripted-looking cadence. 355 sharing events in under three minutes, about two per second. Nine sends in four minutes, ending three seconds before the disable. Thirty-one failed sign-ins in about two minutes once the account was locked.
    ‍

This resembles the reports in places. Google says frameworks like ARTEX compress attack timelines to machine speed and run in short bursts, and Wiz describes steps chained automatically and new IPs appearing within minutes of a block [1][2]. Each resemblance is weak on its own: speed, bursts and retries after a block don't separate AI from scripts or kits, and our bursts lasted minutes, not the seconds Google describes.
‍

What would also explain it

AiTM kits automate session capture, and simple scripts can create a rule, share files and send mail in seconds. Microsoft documented follow-on BEC within five minutes of session theft in 2022, long before agentic frameworks [4]. A practiced operator with a checklist would also produce identical rules.
‍

Some details point the other way. We saw no trial-and-error, where Google and Datadog describe ARTEX-class activity as noisy, with permission-denied errors and sub-agents overwriting each other [1][3]. Parts of the intrusion look manual: the operator VPS had RDP open, the rule names look like stray keystrokes, and one rule came hours after sign-in. And we found no indicator overlap with the infrastructure Wiz and Datadog publish, or the tool-named user agents the reports list [2][3]. That last point is weak evidence, since those lists cover a small share of a widely forked tool, and user agents are easy to change [3].
‍

What would confirm or rule it out

Raising our confidence would take tool-named user agents in sign-in or audit records [3], incremental markers in created object names like the artex-probe patterns Google describes [1], error-driven retries that look like sub-agents colliding [1], overlap with published ARTEX infrastructure, or an operator console on the attacker's hosts [3]. A known phishing-kit fingerprint on the lure host, or signs of a human typing (irregular pauses, typos, corrections), would lower it.
‍

Our confidence

  • High: the post-access stage was fast and followed one fixed recipe.
    ‍
  • Moderate: it was automated or scripted, with a human choosing targets and starting the chain.
    ‍
  • Low: an AI agent drove it. It's plausible and we can't rule it out, but nothing we saw requires it.
    ‍

If you have this kind of evidence in your own incident data, we'd like to hear from you. Either way, the lesson for defenders is the same: plan for an attacker who moves in minutes. A response that waits for an analyst to read an alert is too slow.
‍

How to Hunt for This

What to look for

1. The rule. In the Microsoft 365 unified audit log (Exchange workload), look at New-InboxRule, Set-InboxRule and UpdateInboxRules. Rules created or changed from Outlook or Outlook on the web may show up only as UpdateInboxRules, with the rule details in OperationProperties rather than Parameters. The shape to match:
‍

  • a rule name of three characters or fewer (including punctuation-only names such as ...);
    ‍
  • no conditions, so it applies to all mail;
    ‍
  • an action of DeleteMessage, PermanentDelete or MoveToFolder (to Archive, RSS Feeds or another rarely opened folder);
    ‍
  • often MarkAsRead and StopProcessingRules.


In a 30-day sample of 501 inbox-rule creations and changes across 46 organizations, this shape matched the eight attacker rules and no others.
‍

2. The identity signal around it. Within about 15 minutes of the rule, look for an Entra ID Protection anomalous-token or unfamiliar-sign-in-properties detection, a sign-in from an IP or ASN that's new for the user, and new MFA method registration (User registered security info in the Entra audit log).
‍

3. What came next. Check the following minutes for a burst of outbound sends and for SharePoint or OneDrive sharing bursts (SharingSet, SharingInvitationCreated, AnonymousLinkCreated, CompanyLinkCreated).
‍

Sample queries (Microsoft Sentinel)

These are starting points to adapt, not production-ready detections. Field contents vary by client and audit configuration, so check them against your own data, and tune names, lookbacks and allow-lists.
‍

Query 1: short-named, condition-less inbox rules that hide mail (OfficeActivity)
‍

// Starting point - adapt to your environment.
let lookback = 30d;
// Cmdlet parameters that describe the rule or its actions, not a condition
let nonConditionParams = dynamic(["Identity", "Name", "Mailbox", "Force",
   "AlwaysDeleteOutlookRulesBlob", "Enabled", "Priority", "StopProcessingRules",
   "DeleteMessage", "PermanentDelete", "MoveToFolder", "CopyToFolder",
   "MarkAsRead", "MarkImportance", "ErrorAction", "Confirm"]);
// Rules created or changed with cmdlets (details in Parameters)
let cmdletRules = OfficeActivity
   | where TimeGenerated > ago(lookback)
   | where OfficeWorkload == "Exchange"
   | where Operation in ("New-InboxRule", "Set-InboxRule")
   | mv-apply p = todynamic(Parameters) on (
       summarize Params = make_bag(bag_pack(tostring(p.Name), tostring(p.Value))),
                 ParamNames = make_set(tostring(p.Name))
     )
   | extend RuleName = tostring(split(coalesce(tostring(Params.Name), tostring(Params.Identity)), "\\")[-1]),
            NoConditions = array_length(set_difference(ParamNames, nonConditionParams)) == 0,
            Actions = strcat_delim(";",
                iff(tostring(Params.DeleteMessage) =~ "True", "DeleteMessage", ""),
                iff(tostring(Params.PermanentDelete) =~ "True", "PermanentDelete", ""),
                iff(isnotempty(tostring(Params.MoveToFolder)), strcat("MoveToFolder:", tostring(Params.MoveToFolder)), ""),
                iff(tostring(Params.MarkAsRead) =~ "True", "MarkAsRead", ""),
                iff(tostring(Params.StopProcessingRules) =~ "True", "StopProcessingRules", ""));
// Rules created or changed from Outlook / OWA (details in OperationProperties)
let clientRules = OfficeActivity
   | where TimeGenerated > ago(lookback)
   | where OfficeWorkload == "Exchange"
   | where Operation == "UpdateInboxRules"
   | mv-apply op = OperationProperties on (
       summarize Props = make_bag(bag_pack(tostring(op.Name), tostring(op.Value)))
     )
   | extend RuleName = tostring(Props.RuleName),
            NoConditions = isempty(tostring(Props.RuleCondition)),
            Actions = tostring(Props.RuleActions);
union cmdletRules, clientRules
| where strlen(RuleName) between (1 .. 3)
| where NoConditions
| where Actions matches regex @"(?i)delete|move"
| project TimeGenerated, UserId, ClientIP, Operation, RuleName, Actions
| order by TimeGenerated desc

Query 2: inbox-rule changes within 15 minutes of a token-risk detection, with new-ASN sign-ins (OfficeActivity, AADUserRiskEvents, SigninLogs)

// Starting point - adapt to your environment.
let lookback = 7d;
let baseline = 30d;
let window = 15m;
let ruleChanges = OfficeActivity
   | where TimeGenerated > ago(lookback)
   | where OfficeWorkload == "Exchange"
   | where Operation in ("New-InboxRule", "Set-InboxRule", "UpdateInboxRules")
   | project RuleTime = TimeGenerated, UPN = tolower(UserId), Operation, RuleClientIP = ClientIP;
let riskSignals = AADUserRiskEvents
   | where TimeGenerated > ago(lookback + 1d)
   | where RiskEventType in ("anomalousToken", "unfamiliarFeatures", "investigationsThreatIntelligence")
   | project RiskTime = DetectedDateTime, UPN = tolower(UserPrincipalName), RiskEventType, RiskIP = IpAddress;
// ASNs each user signed in from successfully before the hunt window
let knownAsns = SigninLogs
   | where TimeGenerated between (ago(baseline + lookback) .. ago(lookback))
   | where ResultType == "0"
   | summarize KnownAsns = make_set(AutonomousSystemNumber) by UPN = tolower(UserPrincipalName);
let newAsnSignins = SigninLogs
   | where TimeGenerated > ago(lookback + 1d)
   | where ResultType == "0"
   | project SigninTime = TimeGenerated, UPN = tolower(UserPrincipalName),
             SigninIP = IPAddress, Asn = AutonomousSystemNumber, UserAgent
   | join kind=leftouter knownAsns on UPN
   | where isnull(KnownAsns) or not(set_has_element(KnownAsns, Asn));
ruleChanges
| join kind=inner riskSignals on UPN
| where RuleTime between ((RiskTime - window) .. (RiskTime + window))
| join kind=leftouter newAsnSignins on UPN
| extend NewAsnNearRule = isnotnull(SigninTime) and SigninTime between ((RuleTime - window) .. (RuleTime + window))
| summarize RiskTypes = make_set(RiskEventType),
           RiskIPs = make_set(RiskIP),
           NewAsnIPs = make_set_if(SigninIP, NewAsnNearRule),
           NewAsns = make_set_if(Asn, NewAsnNearRule)
   by UPN, RuleTime, Operation, RuleClientIP
| order by RuleTime desc


In Defender XDR, the same rule events are in CloudAppEvents (ActionType = the operation, details in RawEventData); Microsoft's AiTM post has a query tying new inbox rules to anomalous-token sessions [4].
‍

What to change

  • Require phishing-resistant MFA (FIDO2 or passkeys) for all users, and compliant devices for browser access through Conditional Access; turn on token protection and CAE where supported [1][4][6].
    ‍
  • Automate containment. Here, automated disabling, token revocation and password resets limited the damage.
    ‍
  • After containment, remove the rule and any new MFA methods, and review what was hidden, shared and sent.
    ‍

The Bottom Line

Session-stealing phishing such as AiTM turns MFA into a speed bump. The attacker holds a valid session, so the sign-in alone often looks normal.
‍

The giveaway was what came next: a session used from somewhere else, then, within minutes, an inbox rule nobody would write on purpose.
‍

The chain usually ran in minutes, with the same recipe on every account. That fits automated tooling, and it's why we asked whether AI was behind it. Our evidence is speed and consistency, which conventional kits and scripts also produce, so AI stays a low-confidence hypothesis. Plan for attackers who move this fast either way.
‍

No single alert told the story. Lining up identity risk, mailbox changes and data activity on the same user did.
‍

Indicators of Compromise

Activity window: late October to early November 2026. The IP addresses below are shared infrastructure, also seen at other organizations, so they are low-fidelity indicators: use them for hunting and time-boxed review, not as proof of compromise. Match the single IP only, not the surrounding range. The attacker's dedicated hosting addresses, which we saw only at this organization, are not listed.

‍

IndicatorTypeRole in this intrusionNotes
187.13.143.77IPv431 failed sign-ins on one account in about two minutes after containmentPacketHub VPN exit. Shared: seen at 7 organizations in Reco's telemetry over 30 days. Low fidelity
194.62.107.95IPv4Mail reads on one account 20 seconds after it was disabledLimestone Networks hosting. Also seen at one other organization (October 19, 2026). Low to medium fidelity
infomhoes.topDomainLet's Encrypt certificate on the operator VPS, issued shortly before the activityContext for infrastructure pivoting, not a mail or URL indicator
Inbox rule named a, c, cc, d, V, or literally ... (three periods)Inbox rule nameThe hiding ruleHigh fidelity only in combination with no conditions and a Delete, PermanentDelete or MoveToFolder action
Go-http-client/1.1User agentBackground password spraying against the organizationCommon and generic. Not tied to the compromises

‍

MITRE ATT&CK Mapping

‍

TacticTechniqueHow it showed up
Resource DevelopmentT1583.001 Acquire Infrastructure: DomainsRotating lure domains on the phishing host (passive DNS; inferred)
Resource DevelopmentT1583.003 Acquire Infrastructure: Virtual Private ServerDedicated hosting at MillenialHost (likely AiTM) and CrownCloud (operator VPS)
Initial AccessT1566.002 Phishing: Spearphishing LinkLikely entry vector; delivery mechanism unobserved in the telemetry
Credential Access, CollectionT1539 Steal Web Session CookieAiTM reverse-proxy phishing resulting in authenticated session cookies
Credential AccessT1110.003 Password SprayingObserved against the organization; not confirmed as the entry vector
Lateral MovementT1550.004 Use Alternate Authentication Material: Web Session CookieReplaying stolen cookies from secondary IPs, flagged as anomalous-token events
Initial Access, Persistence, StealthT1098.005 Account Manipulation: Device RegistrationRegistering a new MFA method on one account prior to inbox rule creation
StealthT1070.008 Indicator Removal: Email Hiding RulesCondition-less inbox rules with 1–3 char names deleting, permanently deleting, or archiving mail
PersistenceT1137.005 Office Application Startup: Outlook RulesUsing inbox rules to maintain visibility and suppress alert notifications
CollectionT1114.002 Email Collection: Remote Email CollectionReading mail via Outlook on the web, observed continuing post-account-disable
Lateral MovementT1534 Internal SpearphishingBurst of 9 outbound emails sent within minutes of compromise; recipients unknown

‍

References

[1] Google Threat Intelligence Group, "Shifting Perspectives: Exploring Threat Actor Use of AI and Machine Learning," 2026. https://cloud.google.com/blog/topics/threat-intelligence

[2] Wiz Research, "Under the Radar: Investigating LLM-Powered Cyber Attacks," 2026. https://www.wiz.io/blog

[3] Datadog Security Labs, "Agent of Chaos: Detecting Automated Offensive AI Frameworks in the Wild," 2026. https://securitylabs.datadoghq.com

[4] Microsoft Threat Intelligence, "From cookie theft to BEC: Attackers use adversary-in-the-middle phishing to steal session cookies and deploy follow-on attacks," July 2022. https://www.microsoft.com/en-us/security/blog/2022/07/12/from-cookie-theft-to-bec-attackers-use-adversary-in-the-middle-phishing-to-steal-session-cookies-and-deploy-follow-on-attacks/

[5] Microsoft Learn, "Configurable token lifetimes in the Microsoft identity platform," 2026. https://learn.microsoft.com/en-us/entra/identity-platform/configurable-token-lifetimes

[6] Microsoft Learn, "Continuous access evaluation in Microsoft Entra ID," 2026. https://learn.microsoft.com/en-us/entra/identity/conditional-access/concept-continuous-access-evaluation

No items found.

Ophir Kelman and Gilad Israeli Shilon

ABOUT THE AUTHOR

Technical Review by:
Gal Nakash
Technical Review by:
Ophir Kelman and Gilad Israeli Shilon

Table of Contents
Let’s Talk About Your Non-Human Users
Chat with us
Get the Latest SaaS Security Insights
Subscribe to receive updates on the latest cyber security attacks and trends in SaaS Security.

Be the team that enabled agents without losing control.

Want to look around first? Take a platform tour →