← All hunts high TLP:CLEAR Part 1 of 2

Agentic Identity and Cloud Control Plane Exploitation

An intruder is using an agentic framework to automate cloud API interactions and identity access, characterized by successful sign-ins from unmanaged devices followed by high-tempo API bursts and local CLI tool usage.

Based on research by Elastic Security Labs 2026-11-14 9 steps · 3 queries T1059 T1078 T1090.003 T1505.003

Brief

Why now

Offensive security researchers recently detailed how agentic AI frameworks automate the decision-making process for attackers. In the article "Inside the loop: Five AI attack frameworks that never ask permission" (https://www.elastic.co/security-labs/threat-command/agentic-offensive-frameworks-detection-artex), the authors describe how tools like ARTEX and CyberStrikeAI issue API commands in bursts of 2 to 25 seconds. This speed defeats manual triage. We published this hunt to find the specific footprint of these frameworks in cloud environments.

How the hunt flows

The first phase identifies successful authentications to platforms like AWS, GitHub, or Entra ID that originate from unmanaged or unknown devices. This query scopes the hunt to identities that lack a verified device posture, providing the initial leads for potential session abuse.

The second phase runs two searches in parallel. One query scans cloud API logs for rare, non-browser User-Agents such as Boto3, Python-requests, or the AWS CLI. It filters for agents seen on very few cloud accounts to highlight framework defaults rather than enterprise-wide scripts. Simultaneously, another query checks the hosts identified in the first phase for the execution of cloud management tools or scripting interpreters like Terraform and Python.

Finally, the hunt uses an agent to synthesize the timing of these events. The agent evaluates whether the API bursts and local processes began immediately after the unmanaged sign-in. This temporal correlation helps distinguish a human developer from an automated offensive agentic loop.

What this hunt cannot see

This hunt relies on management events. If an attacker performs high-tempo data exfiltration inside an S3 bucket, it remains invisible unless the environment captures detailed CloudTrail Data Events. Furthermore, if the framework runs inside a short-lived container where no endpoint agent is present, the hunt loses visibility into the local process activity, leaving only the cloud API logs for analysis.

In this series

Steps

  1. Cloud sign-ins from unmanaged devices

    Query · scoping

    Identify successful authentications to critical cloud platforms originating from unmanaged devices or unknown workstations, providing the lead for session abuse.

    reads hb_auth_signinsql
    SELECT actor_user_name, src_endpoint_ip, src_endpoint_hostname, device_hostname, provider, device_trust_type, time FROM hb_auth_signin WHERE activity_id = 1 AND status_id = 1 AND (device_is_compliant = 'false' OR device_trust_type IS NULL OR device_trust_type = '') AND instr(',' || '{{target_providers}}' || ',', ',' || LOWER(provider) || ',') > 0 AND time >= datetime('now', '-{{lookback_days}} days')

    What a hit looks like. A list of users and source hosts that signed into cloud services without a managed device context. Silence suggests all sign-ins were from trusted devices.

  2. Rare automated User-Agents in cloud API logs

    Query · baseline

    Detect non-browser tools like Boto3 or Python-requests that are rare across the environment, which often facilitate agentic framework interactions.

    reads hb_cloud_api_activitysql
    SELECT user_agent, actor_user_name, provider, COUNT(DISTINCT cloud_account_uid) AS accounts, COUNT(*) AS calls, MIN(time) AS first_seen FROM hb_cloud_api_activity WHERE (LOWER(user_agent) LIKE '%python%' OR LOWER(user_agent) LIKE '%boto%' OR LOWER(user_agent) LIKE '%aws-cli%' OR LOWER(user_agent) LIKE '%curl%') AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY user_agent, actor_user_name, provider HAVING accounts <= 2

    What a hit looks like. User-Agents corresponding to scripting libraries or CLIs seen on very few cloud accounts. Normal administrative scripts might appear, but framework defaults will be distinct.

  3. Cloud CLI and scripting on endpoints

    Query · enrichment

    Correlate cloud API activity with local process execution of cloud CLI tools or scripting interpreters, scoped to the hosts from the first step.

    reads hb_process_activitysql
    SELECT device_hostname, process_name, process_cmd_line, user_name, time FROM hb_process_activity WHERE (LOWER(process_name) LIKE '%aws%' OR LOWER(process_name) LIKE '%az.exe%' OR LOWER(process_name) LIKE '%gcloud%' OR LOWER(process_name) LIKE '%python%' OR LOWER(process_name) LIKE '%terraform%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')

    What a hit looks like. Execution of cloud management tools or scripting interpreters on the identified hosts. Silence means no such tools ran on the scoped hosts.

  4. Triage Identity and API Evidence

    Agent triage

    Synthesize sign-in data, user-agent rarity, and local process activity to determine if an agentic loop is active.

  5. Evaluate Triage Verdict

    Decision

    Route to containment if an agentic framework is confirmed.

  6. Revoke Cloud Sessions

    Response action

    Neutralize the automated agent by revoking tokens and forcing a re-authentication.

  7. Analyst review and tuning

    Analyst task

    Verify the agent's findings and distinguish malicious automation from legitimate administrative work.

  8. Close out

    Analyst task

    Document findings and update baseline for known automation.

Coverage

Scenario coverage

StageCoveredHow, or why not
Agentic Cloud and Identity Access
T1078
Yes untrusted-cloud-sign-ins, rare-automation-user-agents, endpoint-cloud-tooling
Initial Access via Extensions and Exploits
T1176 · T1190
Out of scope Belongs to another part of the 'Inside the loop: Five AI attack frameworks that never ask permission' series.
High-Tempo Command and Tool Execution
T1059 · T1558.003
Out of scope Belongs to another part of the 'Inside the loop: Five AI attack frameworks that never ask permission' series.
Persistence via Implants and WebShells
T1505.003 · T1547.001 · T1053.005
Out of scope Belongs to another part of the 'Inside the loop: Five AI attack frameworks that never ask permission' series.
C2 and Proxy Infrastructure
T1090.003
Out of scope Belongs to another part of the 'Inside the loop: Five AI attack frameworks that never ask permission' series.

Blind spots

  • Needs Detailed CloudTrail Data Events or UAL Advanced Audit. A hunt relying only on management events will miss high-tempo data exfiltration bursts. It would answer whether individual read/write operations inside a storage bucket were performed.
  • Needs hb_process_activity with container context. If the endpoint agent is not present on the container host, the process activity will be invisible, leaving only the cloud API logs. It would answer whether the framework ran inside a short-lived container (e.g. Cairn).

Parameters & data

Parameters

ParameterTypeDefaultWhat it is
lookback_daysnumber14Days of history to examine.
scope_hostslist[host]—Workstation or server names identified in the sign-in scoping to focus endpoint process analysis.
target_providerslist[string]aws, github, azure_ad, m365, slackCloud and SaaS providers targeted by agentic frameworks.

Telemetry

SourceCategoryTelemetry
Endpoint telemetry (hb_ surfaces)endpointendpoint
Identity / sign-in telemetryidentityidentity

Source

Download hunt.md Definition (JSON) An open hunt.md file; it runs anywhere that reads the format.
---
analysis: A single detection rule might flag a suspicious User-Agent, but it cannot
  correlate the 'Identity + Automation + Endpoint' triad. The hunt context allows
  an analyst to weigh whether a rare Boto3 agent is a new developer or an ARTEX worker.
blind_spots:
- id: limited-cloud-logging
  question: whether individual read/write operations inside a storage bucket were
    performed
  requires: Detailed CloudTrail Data Events or UAL Advanced Audit
  risk: A hunt relying only on management events will miss high-tempo data exfiltration
    bursts.
  stage: agentic-cloud-identity-access
- id: ephemeral-infrastructure
  question: whether the framework ran inside a short-lived container (e.g. Cairn)
  requires: hb_process_activity with container context
  risk: If the endpoint agent is not present on the container host, the process activity
    will be invisible, leaving only the cloud API logs.
  stage: agentic-cloud-identity-access
coverage:
- stage: agentic-cloud-identity-access
  status: covered
  steps:
  - untrusted-cloud-sign-ins
  - rare-automation-user-agents
  - endpoint-cloud-tooling
- reason: 'Belongs to another part of the ''Inside the loop: Five AI attack frameworks
    that never ask permission'' series.'
  stage: initial-access-extensions-and-exploits
  status: out_of_scope
- reason: 'Belongs to another part of the ''Inside the loop: Five AI attack frameworks
    that never ask permission'' series.'
  stage: high-tempo-command-execution
  status: out_of_scope
- reason: 'Belongs to another part of the ''Inside the loop: Five AI attack frameworks
    that never ask permission'' series.'
  stage: persistence-via-implants-and-webshells
  status: out_of_scope
- reason: 'Belongs to another part of the ''Inside the loop: Five AI attack frameworks
    that never ask permission'' series.'
  stage: c2-and-proxy-infrastructure
  status: out_of_scope
guardrails:
  claims: no_unsupported
  evidence: citation_required
  missing_data: not_benign
  telemetry: untrusted
hunt:
  applicability: campaign-specific
  handoff: keep-as-periodic-hunt
  justification: Agentic frameworks operate at a tempo that defeats manual response
    and single-behavior logic; a coordinated hunt for the 'unmanaged-access + automated-burst'
    pattern is required to identify automated persistence in cloud control planes.
  methodology: model-assisted
  trigger: intel-report
hypothesis: An intruder is using an agentic framework to automate cloud API interactions
  and identity access, characterized by successful sign-ins from unmanaged devices
  followed by high-tempo API bursts and local CLI tool usage.
labels:
- hunt
- attack.t1078
- attack.t1059
- attack.t1090.003
- attack.t1505.003
- command and control
- execution
- initial access
- persistence
name: Agentic Identity and Cloud Control Plane Exploitation
parameters:
  lookback_days:
    default: '14'
    description: Days of history to examine.
    type: number
  scope_hosts:
    default: []
    description: Workstation or server names identified in the sign-in scoping to
      focus endpoint process analysis.
    type: list[host]
  target_providers:
    default:
    - aws
    - github
    - azure_ad
    - m365
    - slack
    description: Cloud and SaaS providers targeted by agentic frameworks.
    from:
      kind: article
      observed: '2026-11-13'
      ref: https://www.elastic.co/security-labs/threat-command/agentic-offensive-frameworks-detection-artex
    type: list[string]
provenance:
  authors:
  - name: Huntbase hunt generation
    org: huntbase.io
  generated:
    by: huntbase-hunt-generation
    from: https://www.elastic.co/security-labs/threat-command/agentic-offensive-frameworks-detection-artex
    gates:
    - dry-run
    - lint
    - critic
    model: hb_google/gemini-3-flash-preview
rationale: Focus on AWS, Entra ID, and GitHub logs. Look for successful sign-ins where
  device compliance is false or missing, then use those source hosts to narrow the
  endpoint process search.
references:
- name: 'Inside the loop: Five AI attack frameworks that never ask permission'
  url: https://www.elastic.co/security-labs/threat-command/agentic-offensive-frameworks-detection-artex
related:
- hunt: high-tempo-command-execution
  reason: This hunt identifies the cloud entry, while the follow-on hunt looks at
    the host-level command bursts.
  relation: follows
scenario:
  stages:
  - name: Initial Access via Extensions and Exploits
    observables:
    - ARTEX browser extension recording authenticated sessions
    - Vulnerability discovery scanning using stock settings
    - Exploitation of public-facing web applications
    - User-Agent strings identifying frameworks
    slug: initial-access-extensions-and-exploits
    tactic: initial-access
    techniques:
    - T1176
    - T1190
  - name: Agentic Cloud and Identity Access
    observables:
    - Sign-ins to AWS, Entra ID, Slack, and GitHub
    - Abuse of recorded session tokens from extensions
    - Automation of cloud CLI tools for account access
    slug: agentic-cloud-identity-access
    tactic: initial-access
    techniques:
    - T1078
  - name: High-Tempo Command and Tool Execution
    observables:
    - Command bursts occurring in 2-25 second intervals
    - Execution of curl, shells, and cloud CLIs
    - Model Context Protocol (MCP) server function calls (HexStrike)
    - Reflector agents sending human-like message responses (PentAGI)
    - Credential access actions including Kerberoasting
    slug: high-tempo-command-execution
    tactic: execution
    techniques:
    - T1059
    - T1558.003
  - name: Persistence via Implants and WebShells
    observables:
    - CyberStrikeAI WebShell manager connections
    - Creation of custom implants checking in every 5 seconds
    - Registry Run keys for implant startup
    - Windows Scheduled Tasks for recurring execution
    - Dropping of coding agent workers in containers (Cairn)
    slug: persistence-via-implants-and-webshells
    tactic: persistence
    techniques:
    - T1505.003
    - T1547.001
    - T1053.005
  - name: C2 and Proxy Infrastructure
    observables:
    - Connections to Telegram, Slack, Discord, and DingTalk C2 listeners
    - DNS queries for update.pentagi.com and com.apple.systemupdate
    - Traffic targeting 224.0.0.0
    - Routing through multi-hop proxies to bypass IP bans
    slug: c2-and-proxy-infrastructure
    tactic: command-and-control
    techniques:
    - T1090.003
  summary: Agentic offensive frameworks like ARTEX and CyberStrikeAI automate attack
    sequences using LLM planners to orchestrate tools like scanners, cloud CLIs, and
    custom implants in high-tempo bursts. These frameworks frequently bypass human
    authorization, interacting with cloud control planes and host endpoints via rapid-fire
    command execution and persistent backdoors.
series:
  index: 1
  slug: inside-the-loop-five-ai-attack-frameworks-that-never-ask-permission
  title: 'Inside the loop: Five AI attack frameworks that never ask permission'
  total: 2
severity: high
targets:
  analyst:
    name: Tier-2 analyst
    role: analyst
  endpoint:
    category: endpoint
    name: Endpoint telemetry (hb_ surfaces)
    telemetry:
    - endpoint
  hunter:
    agent: true
    name: Hunt agent
  identity:
    category: identity
    name: Identity / sign-in telemetry
    telemetry:
    - identity
tlp: clear
type: investigation
---


# Agentic Identity and Cloud Control Plane Exploitation

This hunt identifies the footprint of agentic offensive frameworks like ARTEX and CyberStrikeAI in cloud environments. These frameworks automate the 'think-time' of an operator, issuing API commands in bursts of 2 to 25 seconds. We look for successful authentications to cloud and SaaS providers (AWS, GitHub, Entra ID) from unmanaged devices or unknown hosts, then correlate these identities with high-frequency API activity and the use of automated User-Agents or local cloud CLI tools that are rare across the environment. An agent evaluates the temporal proximity of the sign-in to the API bursts to distinguish automated agents from human administrators.

## untrusted-cloud-sign-ins
<!-- Cloud sign-ins from unmanaged devices -->
Identify successful authentications to critical cloud platforms originating from unmanaged devices or unknown workstations, providing the lead for session abuse.

```sqlite target=identity role=scoping params=(lookback_days=lookback_days, target_providers=target_providers)
~~~yaml
expected: A list of users and source hosts that signed into cloud services without
  a managed device context. Silence suggests all sign-ins were from trusted devices.
reads:
- actor_user_name
- src_endpoint_ip
- src_endpoint_hostname
- device_hostname
- provider
- device_trust_type
- device_is_compliant
- status_id
- activity_id
- time
silence: not_evidence_of_absence
source: hb_auth_signin
verified: dry-run
verified_at: '2026-11-14'
~~~
SELECT actor_user_name, src_endpoint_ip, src_endpoint_hostname, device_hostname, provider, device_trust_type, time FROM hb_auth_signin WHERE activity_id = 1 AND status_id = 1 AND (device_is_compliant = 'false' OR device_trust_type IS NULL OR device_trust_type = '') AND instr(',' || '{{target_providers}}' || ',', ',' || LOWER(provider) || ',') > 0 AND time >= datetime('now', '-{{lookback_days}} days')
```

## analyze-activity
<!-- Analyze behavior for automation and bursts -->
parallel:
- → rare-automation-user-agents
- → endpoint-cloud-tooling
join: → triage-agentic-activity

## rare-automation-user-agents
<!-- Rare automated User-Agents in cloud API logs -->
Detect non-browser tools like Boto3 or Python-requests that are rare across the environment, which often facilitate agentic framework interactions.

```sqlite target=endpoint role=baseline params=(lookback_days=lookback_days)
~~~yaml
baseline:
  compare: first_seen
  window: '{{lookback_days}}d'
expected: User-Agents corresponding to scripting libraries or CLIs seen on very few
  cloud accounts. Normal administrative scripts might appear, but framework defaults
  will be distinct.
prevalence:
  by: cloud_account_uid
  key:
  - user_agent
  rare_below: 3
reads:
- user_agent
- actor_user_name
- provider
- cloud_account_uid
- time
silence: not_evidence_of_absence
source: hb_cloud_api_activity
verified: dry-run
verified_at: '2026-11-14'
~~~
SELECT user_agent, actor_user_name, provider, COUNT(DISTINCT cloud_account_uid) AS accounts, COUNT(*) AS calls, MIN(time) AS first_seen FROM hb_cloud_api_activity WHERE (LOWER(user_agent) LIKE '%python%' OR LOWER(user_agent) LIKE '%boto%' OR LOWER(user_agent) LIKE '%aws-cli%' OR LOWER(user_agent) LIKE '%curl%') AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY user_agent, actor_user_name, provider HAVING accounts <= 2
```

## endpoint-cloud-tooling
<!-- Cloud CLI and scripting on endpoints -->
Correlate cloud API activity with local process execution of cloud CLI tools or scripting interpreters, scoped to the hosts from the first step.

```sqlite target=endpoint role=enrichment params=(lookback_days=lookback_days, scope_hosts=scope_hosts)
~~~yaml
expected: Execution of cloud management tools or scripting interpreters on the identified
  hosts. Silence means no such tools ran on the scoped hosts.
reads:
- device_hostname
- process_name
- process_cmd_line
- user_name
- time
silence: not_evidence_of_absence
source: hb_process_activity
verified: dry-run
verified_at: '2026-11-14'
~~~
SELECT device_hostname, process_name, process_cmd_line, user_name, time FROM hb_process_activity WHERE (LOWER(process_name) LIKE '%aws%' OR LOWER(process_name) LIKE '%az.exe%' OR LOWER(process_name) LIKE '%gcloud%' OR LOWER(process_name) LIKE '%python%' OR LOWER(process_name) LIKE '%terraform%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')
```

## triage-agentic-activity
<!-- Triage Identity and API Evidence -->
```agent target=hunter
cite: required
context:
- untrusted-cloud-sign-ins
- rare-automation-user-agents
- endpoint-cloud-tooling
max_iterations: 5
objective: 'Determine if the combination of unmanaged cloud sign-ins, rare automation
  user-agents, and local cloud CLI usage indicates an automated offensive framework
  like ARTEX or CyberStrikeAI. Analyze the timing: do the API calls and local processes
  start immediately after the unmanaged sign-in?'
success_criteria: A verdict of malicious | suspicious | benign per identity, citing
  specific rows and timestamps.
tools:
- endpoint
- identity
```

## evaluate-verdict
<!-- Evaluate Triage Verdict -->
if~: "the triage verdict is malicious for at least one user identity" (confidence: high, judge=hunter)
then: → revoke-sessions
indeterminate: → analyst-manual-review
unavailable: → analyst-manual-review (blind_spot: limited-cloud-logging)
else: → close-out

## revoke-sessions
<!-- Revoke Cloud Sessions -->
```action target=identity
~~~yaml
approval: required
~~~
Revoke all active sessions and refresh tokens for the identified user across the impacted cloud providers. Reset credentials and rotate access keys if applicable.
```
→ analyst-manual-review

## analyst-manual-review
<!-- Analyst review and tuning -->
```manual target=analyst
Review the identified User-Agents and local process command lines. Correlate with internal engineering schedules to ensure these weren't legitimate automation tasks. If malicious, initiate the full incident response process.
```
→ close-out

## close-out
<!-- Close out -->
```manual target=analyst
Document the identified automated User-Agents. If benign, add them to a known-automation allow-list for future periodic hunts.
```
→ end

Run it

Take this hunt into your environment.

Open it in Huntbase to run every step against your own connections, with Scout weighing the evidence and your analysts in command. Or take the open hunt.md file anywhere that reads the format.

Machine-drafted by huntbase-hunt-generation using hb_google/gemini-3-flash-preview, gated by dry-run, lint, critic, then reviewed by a person.

Locked pack

Sign up to unlock

Pack contents are available to Huntbase users.