← /editions
#30

The Best Defense Is an Agent That Attacks

// Capital One open-sourced VulnHunter, an agentic security tool that reasons like an attacker to find exploitable code flaws and argues against its own findings to kill false positives. It lands the same week Sysdig documented JadePuffer, the first fully autonomous LLM-driven ransomware, alongside Ant Group's SingGuard-NSFA guardrails and Functionize's adversarial testing agents — a wave making clear that offense went agentic, and defense is answering with agents of its own.

$ today_in_10_seconds

Capital One just open-sourced VulnHunter, an agentic AI tool that reasons like an attacker to find exploitable code flaws before they ship — and it's built on Claude Opus 4.8. It lands the same week researchers documented the first fully autonomous AI ransomware operation, making the subtext impossible to miss: offense went agentic, so defense is racing to catch up with agents of its own.

$ lead_story

Capital One open-sources VulnHunter, an attacker-minded code security agent

Capital One released VulnHunter under Apache 2.0 — an agentic security tool that doesn't scan for suspicious patterns like a traditional SAST tool, but reasons like an adversary: it maps entry points to dangerous sinks, identifies which defects are actually exploitable, and proposes evidence-backed fixes. The clever part is a built-in falsification pipeline (Recon → Parallel Hunt → Adversarial Disprove → Capability Filter) that tries to disprove its own findings before a developer ever sees them — a direct attack on the false-positive avalanche that makes most scanners unusable. It ships as three composable Claude Code skills (hunt, fix, verify) built on Claude Opus 4.8, with the fix agent writing an exploit demo, a failing security test, the code fix, and a reviewable PR. For developers, this is a concrete template for turning a frontier model into a disciplined, self-checking security reviewer rather than a confident-but-noisy one.

// why_it_matters: A major bank just handed everyone a working blueprint for agentic defense — and proved the false-positive problem is solvable by making the agent argue against itself.

read more →

$ also_worth_attention

  • The threat VulnHunter is built for just went live: JadePuffer, the first agentic ransomware

    Sysdig documented what it assesses as the first ransomware operation driven end-to-end by an LLM agent: it exploited an internet-facing Langflow instance, harvested credentials, moved laterally, established persistence, and destroyed a database — retrying a failed login and fixing it in 31 seconds along the way. The giveaway was self-narrating payloads full of natural-language targeting rationale, the kind of commentary a human operator wouldn't bother writing. The uncomfortable insight from Sysdig: the skill floor for running ransomware has dropped to whatever it costs to run an agent.

    link →
  • Ant Group ships open-source guardrails for agents — SingGuard-NSFA

    Days after JadePuffer, Ant Group's AI Security Lab open-sourced a guardrail framework that inspects an agent's intended actions before they execute, catching prompt injection, credential theft, malicious code, and permission misuse. It organizes 185 threat scenarios into a taxonomy cross-checked against OWASP, ships in sizes from 0.8B to 9B, and makes a risk decision in ~50ms — fast enough to run inline on every tool call without wrecking latency. The insight: sub-100ms is the threshold that decides whether a guardrail is production infrastructure or shelfware.

    link →
  • Functionize ships an 'adversarial' testing agent to check code built at agent speed

    Functionize launched Studio, a QA platform whose agents build tests against a live app, run them across browsers in parallel, and self-repair as the app changes — deliberately independent of the code they review. The pitch: a coding agent can't prove the quality of its own output, so verification needs an agent with the opposing objective, equal in capability. It reads what the app does by watching it run rather than reading the source, and aims for deterministic results so teams can tell a real regression from noise.

    link →

$ bigger_picture

The trend behind the headlines

Today's stories rhyme around a single idea: as agents write and attack software autonomously, the only thing that scales to check them is another agent with an opposing objective. JadePuffer shows the offensive side is no longer hypothetical — an LLM chained a full ransomware operation against neglected infrastructure with no operator expertise required. The response, arriving almost simultaneously, is a wave of adversarial and defensive agents: VulnHunter reasoning like an attacker to harden code, SingGuard intercepting malicious actions before they fire, Functionize proving software works by trying to break it. Notice the shared design principle across all three — self-falsification, independent verification, pre-execution inspection — because an agent that only confirms its own conclusions is worse than useless at scale. The verification layer, not raw generation, is quietly becoming the most important part of the agentic stack.

$ tool_of_the_day

VulnHunter

Worth a look even if you're not in security, because it's a clean, open example of agentic engineering done right: composable Claude Code skills, an explicit falsification pipeline, and a test-driven fix loop that produces a reviewable PR instead of a wall of alerts. Note the one real prerequisite — it needs Claude Opus 4.8 and a working Claude Code environment, and its dual-use cyber work may hit safeguards on accounts not enrolled in Anthropic's Cyber Verification Program.

explore VulnHunter →

$ subscribe --free

Get the next edition in your inbox

// DAIly Agent covers agentic AI three times a week

// free, no spam, exit anytime