---
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
