Back to Intelligence

Securing AI Agents in Claude Cowork: CrowdStrike Falcon Detection and Hardening Guide for Enterprise Defenders

SA
Security Arsenal Team
November 3, 2026
9 min read

CrowdStrike has announced native security coverage for AI agents operating inside Anthropic's Claude Cowork environment — extending Falcon platform visibility into what is quickly becoming the most dangerous new execution surface in the enterprise: autonomous AI agents with legitimate access to files, browsers, terminals, and SaaS data.

If your organization hasn't internalized this yet, let me be direct: AI agents are no longer productivity toys. They are privileged execution frameworks running under user identities, making API calls, reading mailboxes, writing files, and invoking tools via Model Context Protocol (MCP) servers — often with none of the endpoint telemetry, allow-listing, or identity governance we apply to any other software doing the same things. From an attacker's perspective, a compromised or manipulated agent is the perfect insider: trusted, credentialed, and poorly logged.

CrowdStrike's move signals what those of us in IR have been warning about for the past year — prompt injection, malicious MCP servers, and agent-driven data exfiltration are now operational attack chains, not conference-talk hypotheticals. This post breaks down the threat model, what Falcon's coverage means for defenders, and the detection engineering your SOC should implement whether or not you're a CrowdStrike shop.

Technical Analysis: The AI Agent Attack Surface

What's Being Protected

Claude Cowork (Anthropic's agentic desktop/workplace offering) allows Claude-powered agents to perform multi-step tasks: reading and writing local files, executing shell commands, browsing, and connecting to third-party tools through MCP servers. CrowdStrike's integration extends Falcon sensor visibility and policy enforcement into this agent runtime — monitoring agent-initiated process execution, file access, and network activity, and applying behavioral prevention against malicious agent actions.

Why This Matters — The Threat Model

From a defender's standpoint, agentic AI introduces four distinct attack classes:

  1. Prompt Injection (Direct and Indirect): Adversaries embed instructions in content the agent ingests — emails, web pages, documents, ticket comments. The agent, acting with the user's privileges, is manipulated into exfiltrating data, executing commands, or disabling controls. Indirect injection is the nastier variant: the user never sees the malicious instruction at all.

  2. Malicious MCP Servers and Tool Poisoning: MCP servers define what tools an agent can invoke. A rogue or compromised MCP server can intercept data flowing through the agent, inject instructions, or redirect tool calls. Attackers are already seeding lookalike MCP packages in public registries — classic supply-chain tradecraft applied to a brand-new ecosystem with almost no vetting.

  3. Shadow AI and Ungoverned Agent Deployment: Users install agentic tooling outside IT approval. These agents hold OAuth tokens, session cookies, and file-system access with zero logging. You cannot protect what you cannot enumerate.

  4. Agent-Enabled Data Exfiltration: An agent with mailbox, Drive, and filesystem access is a turnkey exfiltration pipeline. One successful injection turns a productivity tool into an insider threat that moves at machine speed.

Exploitation Status

There is no CVE associated with this announcement — this is a defensive capability release, not a vulnerability disclosure. However, prompt injection and tool-poisoning techniques against agentic AI systems have been demonstrated publicly and observed in red-team engagements throughout 2025 and into 2026. Treat this as an active technique class, not a theoretical one. MITRE has also extended its ATLAS framework coverage of these TTPs (e.g., AML.T0051 — LLM Prompt Injection), which is where your detection content should be mapped.

Detection & Response

The detections below target the behaviors that matter regardless of vendor: agent processes spawning unexpected child processes, tampering with agent/MCP configuration, and unsanctioned agent runtimes appearing on endpoints. Tune the process names to the agent tooling actually deployed in your environment.

YAML
---
title: AI Agent Process Spawning Shell or Script Interpreter
id: 3f8a2c91-7d4e-4b6a-9c15-2e8f4a1b6d30
status: experimental
description: Detects Claude Cowork or other AI agent executables spawning command shells or script interpreters, consistent with prompt-injection-driven command execution or malicious tool invocation.
references:
  - https://www.crowdstrike.com/en-us/blog/crowdstrike-secures-ai-agents-inside-claude-cowork/
  - https://atlas.mitre.org/techniques/AML.T0051
author: Security Arsenal
date: 2026/02/11
tags:
  - attack.execution
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\claude.exe'
      - '\Claude.exe'
      - '\claude-cowork.exe'
      - '\anthropic-agent.exe'
  selection_child:
    Image|endswith:
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\cmd.exe'
      - '\rundll32.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\curl.exe'
      - '\wget.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Approved agent workflows that legitimately execute scripts or fetch remote content — baseline by parent command line and user
level: high
---
title: AI Agent or MCP Configuration File Modification
id: 8c1e5a47-3b92-4f68-ad27-9d4c6e0b5f18
status: experimental
description: Detects creation or modification of Claude/MCP configuration files, which may indicate persistence via rogue MCP server registration or tool poisoning.
references:
  - https://www.crowdstrike.com/en-us/blog/crowdstrike-secures-ai-agents-inside-claude-cowork/
author: Security Arsenal
date: 2026/02/11
tags:
  - attack.persistence
  - attack.t1546
logsource:
  category: file_event
  product: windows
detection:
  selection:
    TargetFilename|contains:
      - '\.claude.json'
      - '\claude_desktop_config.json'
      - '\.claude\settings.json'
      - '\mcp.json'
      - '\.mcp\'
  condition: selection
falsepositives:
  - Legitimate user or admin configuration of agent tooling — alert on changes outside change windows or by non-admin users
level: medium
---
title: Unsigned Executable Egress to LLM API Endpoints
id: 5d7b3e29-1a48-4c95-bf62-8a3e9d0c7b41
status: experimental
description: Detects unsigned or unusual processes establishing connections to LLM API endpoints, potentially indicating shadow AI tooling or data staged for exfiltration through an AI service.
references:
  - https://atlas.mitre.org/
author: Security Arsenal
date: 2026/02/11
tags:
  - attack.exfiltration
  - attack.t1567
logsource:
  category: network_connection
  product: windows
detection:
  selection_dest:
    DestinationHostname|contains:
      - 'api.anthropic.com'
      - 'api.openai.com'
  selection_unsigned:
    Signed: 'false'
  condition: selection_dest and selection_unsigned
falsepositives:
  - Developer tooling and unsigned internal scripts using LLM APIs — correlate with process path and user context
level: medium
KQL — Microsoft Sentinel / Defender
// Hunt: AI agent runtimes spawning high-risk child processes or touching sensitive locations
// Tables: DeviceProcessEvents (Defender XDR) — extend with DeviceFileEvents for config tampering
let AgentProcesses = dynamic(["claude.exe", "claude-cowork.exe", "anthropic-agent.exe", "mcp-server.exe"]);
let HighRiskChildren = dynamic(["powershell.exe", "pwsh.exe", "cmd.exe", "rundll32.exe", "mshta.exe", "curl.exe", "wscript.exe"]);
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName in~ (AgentProcesses)
| where FileName in~ (HighRiskChildren)
| project TimeGenerated, DeviceName, AccountName,
    AgentCmdLine = InitiatingProcessCommandLine,
    ChildProcess = FileName,
    ChildCmdLine = ProcessCommandLine,
    SHA256, ReportId
| order by TimeGenerated desc;

// Companion hunt: agent/MCP configuration file changes by non-admin accounts
DeviceFileEvents
| where TimeGenerated > ago(7d)
| where FileName has_any ("claude_desktop_config.json", ".claude.json", "mcp.json", "settings.json")
| where FolderPath has_any ("claude", "mcp", "anthropic")
| project TimeGenerated, DeviceName, InitiatingProcessAccountName, FileName, FolderPath, InitiatingProcessFileName
| order by TimeGenerated desc;
VQL — Velociraptor
-- Hunt for AI agent installations, MCP configuration artifacts, and agent-spawned processes
-- Artifact: Security.AI.AgentSurfaceAudit

-- 1) Enumerate running agent processes and their children
SELECT Pid, Ppid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE Name =~ '(?i)claude|anthropic|mcp'
   OR CommandLine =~ '(?i)claude|mcp-server|anthropic'

-- 2) Locate agent and MCP configuration files across user profiles
SELECT FullPath, Size, Mtime, Btime
FROM glob(globs=[
  'C:/Users/*/AppData/Roaming/Claude/*.json',
  'C:/Users/*/.claude.json',
  'C:/Users/*/.claude/**',
  'C:/Users/*/.mcp/**',
  '/Users/*/Library/Application Support/Claude/*.json',
  '/home/*/.claude.json'
])

-- 3) Review active connections to LLM API infrastructure
SELECT Pid, Name, RemoteAddress, RemotePort, Status
FROM netstat()
WHERE RemoteAddress =~ 'anthropic|openai'
   OR RemotePort in (443) AND Name =~ '(?i)claude|mcp'
PowerShell
# AI Agent Security Baseline Audit — run elevated on Windows endpoints
# 1) Enumerate installed agentic AI tooling (shadow AI discovery)
Write-Host "=== Installed AI Agent Tooling ===" -ForegroundColor Cyan
$paths = @("$env:ProgramFiles", "${env:ProgramFiles(x86)}", "$env:LOCALAPPDATA\Programs")
foreach ($p in $paths) {
    Get-ChildItem -Path $p -Directory -ErrorAction SilentlyContinue |
        Where-Object { $_.Name -match 'claude|anthropic|copilot|cursor|mcp' } |
        Select-Object FullName, CreationTime
}

# 2) Inventory MCP/agent config files and flag recently modified ones
Write-Host "=== Agent/MCP Configuration Files ===" -ForegroundColor Cyan
Get-ChildItem -Path "C:\Users" -Recurse -Include "claude_desktop_config.json",".claude.json","mcp.json" -ErrorAction SilentlyContinue |
    Select-Object FullName, LastWriteTime | Sort-Object LastWriteTime -Descending

# 3) Parse MCP configs for unapproved server entries
Write-Host "=== Registered MCP Servers ===" -ForegroundColor Cyan
Get-ChildItem -Path "C:\Users" -Recurse -Include "claude_desktop_config.json","mcp.json" -ErrorAction SilentlyContinue | ForEach-Object {
    $cfg = Get-Content $_.FullName -Raw | ConvertFrom-Json -ErrorAction SilentlyContinue
    if ($cfg.mcpServers) {
        $cfg.mcpServers.PSObject.Properties | ForEach-Object {
            [PSCustomObject]@{ ConfigFile = $_.Name; Server = $_.Name; Command = $_.Value.command; Args = ($_.Value.args -join ' ') }
        }
    }
}

# 4) Verify CrowdStrike Falcon sensor health (agent protections require a running sensor)
Write-Host "=== Falcon Sensor Status ===" -ForegroundColor Cyan
Get-Service -Name CSFalconService -ErrorAction SilentlyContinue | Select-Object Name, Status, StartType

# 5) Flag agent processes with active external connections
Write-Host "=== Agent Processes with Network Connections ===" -ForegroundColor Cyan
Get-NetTCPConnection -State Established -ErrorAction SilentlyContinue | ForEach-Object {
    $proc = Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue
    if ($proc.Name -match 'claude|mcp|anthropic') {
        [PSCustomObject]@{ Process = $proc.Name; PID = $proc.Id; RemoteIP = $_.RemoteAddress; RemotePort = $_.RemotePort }
    }
}

Remediation and Hardening Guidance

  1. Deploy CrowdStrike's AI agent protections. If you're a Falcon customer, confirm your sensor versions are current and enable the agentic-AI visibility policies via the Falcon console. Review CrowdStrike's official guidance at https://www.crowdstrike.com/en-us/blog/crowdstrike-secures-ai-agents-inside-claude-cowork/ and validate coverage in a test OU before broad rollout.

  2. Establish an AI agent inventory and approval gate. You cannot secure shadow AI. Use the audit script above to enumerate installed agents and registered MCP servers, then stand up an approval workflow: no agent runtime or MCP server enters production without security review, a defined data-access scope, and logging.

  3. Constrain agent permissions by design. Run agents under dedicated service accounts — never the user's full interactive context. Apply least privilege to filesystem, mailbox, and SaaS scopes. Where supported, enforce human-in-the-loop confirmation for destructive or egress actions (file deletion, external email send, outbound API posts).

  4. Vet and pin MCP servers. Treat MCP servers like software dependencies: pin versions, verify signatures/provenance, host approved servers internally, and block unregistered entries via application control (WDAC/AppLocker) plus file-integrity monitoring on configuration files.

  5. Apply prompt-injection countermeasures. Instruct agents to treat all retrieved content as untrusted data. Strip or sandbox instructions embedded in external content, restrict which domains/repositories agents can ingest, and log full agent action traces (tool calls, parameters, results) to your SIEM for retrospective hunting.

  6. Monitor egress to LLM APIs. Alert on unsanctioned processes talking to LLM endpoints and on anomalous data volumes — exfiltration-through-AI is an emerging pattern. Correlate with DLP policy violations.

  7. Update IR playbooks. Add agent compromise scenarios to your incident response plans: how to revoke agent tokens, capture agent action logs, and scope what data an injected agent touched. The first time you do this should not be during a live incident.

The Bottom Line

AI agents are privileged insiders by default, and the industry is only now bolting on the controls we've spent 20 years building for human users. CrowdStrike extending Falcon into Claude Cowork is a meaningful step — but platform coverage is not a substitute for governance, inventory, and detection engineering in your own SOC. Instrument the agent runtime like you instrument endpoints, vet MCP servers like software supply chain, and assume prompt injection will be attempted. The organizations that treat agentic AI as an attack surface today will be the ones not writing breach disclosures tomorrow.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.