llms.txt
Compare with other sites' llms.txt files →# Shoofly
> Drop-in runtime security for OpenClaw and Claude Code agents. Intercepts tool calls before they execute — blocked, not detected.
Shoofly is a pre-execution security layer for AI agent runtimes. It sits between an agent and its tools, evaluating every tool call against an open policy ruleset before execution. Dangerous calls are blocked before they fire. Safe calls proceed normally. Works with OpenClaw and Claude Code (including Dispatch, /loop, and unattended sessions).
## Docs
- [Homepage](https://shoofly.dev): Product overview, pricing, install
- [Shoofly Advanced](https://shoofly.dev/advanced/): Advanced tier — pre-execution blocking, daemon + hook architecture
- [Advanced Setup Guide](https://shoofly.dev/docs/advanced/): Full installation and configuration docs for Shoofly Advanced
- [Security Policy](https://shoofly.dev/security/): Responsible disclosure and security practices
## Tiers
### Shoofly Basic (Free forever)
Detects threats and sends multi-channel alerts. Never blocks. Runs as a background daemon monitoring your agent session logs. Install and forget.
Install: `curl -fsSL https://shoofly.dev/install.sh | bash`
Capabilities:
- Prompt injection detection (8 patterns: instruction suppression, jailbreak keywords, base64 payloads, system prompt override attempts)
- Credential sniffing alerts: Anthropic API keys, GitHub tokens, AWS credentials
- Out-of-scope write detection: writes to /etc/, ~/.ssh/, LaunchAgents, and sensitive system paths
- Runaway loop detection: repeated tool calls, call floods, read-write cycles
- Data exfiltration detection: credentials in POST bodies, pipe exfiltration, read-then-network patterns
- Tool response injection detection: malicious instructions embedded in tool call results
- Multi-channel alerts: Telegram, WhatsApp, macOS notifications, terminal, OpenClaw gateway
### Shoofly Advanced ($5/mo)
Full pre-execution blocking. Two-layer architecture: daemon (monitors + alerts) + hook (intercepts tool calls before they execute and returns a block decision). The hook fires via the before_tool_call lifecycle event — before the tool runs, not after.
Install: `curl -fsSL https://shoofly.dev/install-advanced.sh | bash`
Additional capabilities over Basic:
- Pre-execution blocking: tool calls halted before execution, not just logged
- YAML policy-as-code: open, auditable rules — read them, fork them, customize them. No black-box decisions.
- Policy linting: validate policy files before deployment
- Unattended session protection: designed for Claude Code Dispatch, /loop, and scheduled tasks that run without a human watching
- Claude Code hook support: integrates via Claude Code's PreToolUse dispatch hook
- OpenClaw hook support: integrates via shoofly-hook extension (before_tool_call)
## Claude Code and Dispatch Support
Shoofly v2+ supports Claude Code natively. This includes:
- Hook integration via Claude Code's PreToolUse event (fires before any tool call executes)
- Daemon monitoring for Claude Code session logs
- Protection for unattended Dispatch tasks, /loop scheduled sessions, and remote control sessions
- Claude Code-specific health checks (shoofly-claude-daemon status, hook registration)
Relevant context: Anthropic's auto mode classifier has a documented 17% false-negative rate on dangerous commands. Shoofly's deterministic policy rules operate independently and do not share this failure mode.
## Security Coverage
Shoofly's open ruleset covers 21 threat categories including:
- PI-001–PI-008: Prompt injection variants (ignore/disregard instructions, new system prompts, jailbreak patterns, base64-encoded instructions, role-playing override attempts)
- TRI-001: Tool result injection (fake tool outputs injected into agent context)
- OSW-001–OSW-003: Off-system writes (sensitive path writes, credential file writes)
- RL-001–RL-003: Runaway loops (repetition loops, call floods, read-write cycles)
- DE-001–DE-005: Data exfiltration (credential exfil, read-then-exfil, pipe exfil, POST body credential leak)
- COWORK-001: Cowork plugin detections (Claude Code-specific patterns)
Rules are open and auditable: https://github.com/shoofly-dev/shoofly
## Key Pages
- [OpenClaw Security](https://shoofly.dev/openclaw/): Shoofly for OpenClaw agents — what it protects, how it installs, what the hook intercepts
- [Claude Code Dispatch Security](https://shoofly.dev/claude-code-dispatch/): Shoofly for Claude Code — Dispatch, /loop, remote control, computer use coverage
- [AI Agent Security Guide](https://shoofly.dev/ai-agent-security/): The developer's complete guide to AI coding agent security
- [Agentic AI Security](https://shoofly.dev/agentic-ai-security/): Pre-execution blocking and the decision gate architecture
- [MCP Security](https://shoofly.dev/mcp-security/): MCP tool poisoning prevention — how the attack works and how Shoofly stops it
- [OpenClaw Security Guide](https://shoofly.dev/openclaw-security/): Protecting OpenClaw agent stacks from skills to tool calls
- [Claude Code Security Guide](https://shoofly.dev/claude-code-security/): Prompt injection, CVEs, and how to lock down Claude Code
- [Security Guides](https://shoofly.dev/guides/): All Shoofly security guides
## Blog
- [Prompt Injection Hidden in PDFs: What Your Agent Reads and You Don't](https://shoofly.dev/blog/prompt-injection-hidden-in-pdfs/) — Attackers hide instructions in PDFs as white, tiny or invisible text. Your AI agent reads them; you don't. How it works, real cases, and how to stop it.
- [Single Agent vs Multi-Agent: When Each Pattern Actually Wins](https://shoofly.dev/blog/single-agent-vs-multi-agent/) — One agent or a team of specialists? Both patterns work. The difference is in what you're building and how much complexity you're willing to manage.
- [Claude Code Subagents: How They Work in Practice](https://shoofly.dev/blog/claude-code-subagents/) — Subagents run in their own context window with their own tool access. Here's when they're the right tool, how to define custom subagents, and the gotchas that matter.
- [Claude Code Hooks Explained: What You Can Actually Automate](https://shoofly.dev/blog/claude-code-hooks-explained/) — Claude Code hooks fire before and after every tool call. Here's what they actually do, how to write your first hook, and the production patterns worth building.
- [AI Agent Security: What Can Go Wrong and How to Prevent It](https://shoofly.dev/blog/ai-agent-security/) — AI agents that can execute code, write files, and call APIs create a new security surface. Here's the honest threat model and what actually reduces risk in production.
- [Claude Managed Agents: What You Actually Get](https://shoofly.dev/blog/claude-managed-agents/) — Claude Managed Agents launched April 2026. Here's what the infrastructure handles, what's still gated, how the pricing works, and who should try it now.
- [OpenClaw + Claude Is Now Pay-Per-Token: What It Costs and What to Do Next](https://shoofly.dev/blog/openclaw-claude-billing-change/) — Anthropic ended third-party Claude subscription billing on April 4, 2026. Here's what it actually costs now and your four options.
- [LLM Firewall: Architecture, Comparison, and the Case for Pre-Execution](https://shoofly.dev/blog/llm-firewall/) — Comparing LLM firewalls across prompt filtering, tool call interception, and output scanning — and when each layer applies to your threat model.
- [Vibe Coding Security: Why Scanning Output Isn't Enough](https://shoofly.dev/blog/vibe-coding-security/) — Everyone covers the code vibe coding generates. Nobody covers what the agent does before any code is written — file reads, shell commands, network calls.
- [ClawHavoc: 824 Malicious Skills and the ClawHub Supply Chain Crisis](https://shoofly.dev/blog/clawhavoc/) — Koi Security found 824 confirmed malicious skills in ClawHub — roughly 8% of the registry. Here's the attack patterns, the kill chains, and what runtime policy enforcement catches.
- [Is Claude Code Dispatch Safe? Here's What Anthropic Says (And What You Still Need)](https://shoofly.dev/blog/is-claude-code-dispatch-safe/) — Anthropic's own security numbers for Dispatch, /loop, and computer use. Where the gaps are and what fills them.
- [Claude Code Security Best Practices](https://shoofly.dev/blog/securing-claude-code-best-practices/) — Practical hardening guide for Claude Code deployments.
- [AI Computer Use Security: Attack Vectors and How to Stop Them](https://shoofly.dev/blog/ai-computer-use-security-attack-vectors/) — Unsandboxed computer use, DOM injection, clipboard attacks, proven PoCs.
- [MCP Tool Poisoning: What It Is and How to Stop It](https://shoofly.dev/blog/mcp-tool-poisoning-what-it-is-and-how-to-stop-it/) — How poisoned MCP servers hijack agent tool calls.
- [CVE-2025-59536: Claude Code Config File Exploit](https://shoofly.dev/blog/cve-2025-59536-claude-code-config-file-exploit/) — CVSS 8.7 RCE via malicious hooks in .claude/settings.json.
- [ClawHub Skill Supply Chain Attacks](https://shoofly.dev/blog/clawhub-skill-supply-chain-attacks/) — How malicious skills compromise agent runtimes at install time.
- [AI Coding Agent Security: Full Stack](https://shoofly.dev/blog/ai-coding-agent-security-full-stack/) — End-to-end security architecture for AI coding agent deployments.
- [OpenClaw Skill Security: What Every User Should Know](https://shoofly.dev/blog/openclaw-skill-security-what-every-user-should-know/) — Skill trust boundaries, supply chain risks, and safe installation practices.
- [Prompt Injection Blocking: Pre-Execution Security](https://shoofly.dev/blog/prompt-injection-blocking-pre-execution-security/) — Why blocking at the decision gate is the only effective prompt injection defense.
- [Runtime Threat Detection for AI Agents](https://shoofly.dev/blog/runtime-threat-detection-ai-agents/) — What runtime threat detection looks like in practice for agentic systems.
- [Why We Block Instead of Detect](https://shoofly.dev/blog/why-we-block-instead-of-detect/) — The architectural argument for pre-execution blocking over post-execution detection.
## Install
Basic (free): `curl -fsSL https://shoofly.dev/install.sh | bash`
Advanced ($5/mo): `curl -fsSL https://shoofly.dev/install-advanced.sh | bash`
Claude Code Advanced: `curl -fsSL https://shoofly.dev/install-claude-code-advanced.sh | bash`
ClawHub (Basic): https://clawhub.ai/wow-leeroy-jenkins05/shoofly-basic
ClawHub (Advanced): https://clawhub.ai/wow-leeroy-jenkins05/shoofly-advanced
GitHub: https://github.com/shoofly-dev/shoofly