Synthesized by Clarity (Claude) from 18 sources · May contain errors — spot one? [email protected] · Methodology →
Miasma Worm Spreads via Dependabot Auto-Merge in CI/CD
- Sources
- 18
- Words
- 1,256
- Read
- 6min
Topics Agentic AI AI Capital LLM Inference
◆ The signal
It's ongoing and not contained. If your CI/CD auto-merges Dependabot PRs or uses floating version ranges from Microsoft packages, stop and audit your lockfiles now.
◆ INTELLIGENCE MAP
Intelligence map
01 Self-Replicating Supply Chain Worm + AI Vuln Discovery Acceleration
act nowMiasma worm autonomously compromised 73 Microsoft GitHub repos and poisoned 50+ npm packages with compiled Rust payloads invisible to JS static analysis. Simultaneously, AI agents found 21 FFmpeg zero-days in one pass. Anthropic's Glasswing expanded to 150+ companies. Discovery is outpacing patch capacity structurally.
- Poisoned npm packages
- FFmpeg zero-days
- Glasswing companies
- Cisco CVE (no patch)
02 Agent Security Architecture Collapse: Prompt Injection Declared Unsolvable
act nowOpenAI shipped Lockdown Mode — it disables Deep Research and Agent Mode entirely rather than hardening them. Meta's AI chatbot was socially engineered into hijacking Instagram accounts via write access to auth. Claude Code's MCP protocol has an active exploit. Microsoft published 7 new AI agent failure modes. The industry consensus: prompt-level guardrails are not security boundaries.
- OpenAI response
- Meta exploit vector
- MS failure modes
- Fix
- Meta chatbot exploitAccount takeover via conversation
- Claude MCP vulnProtocol-level exploit active
- MS taxonomy update7 new agent failure modes
- OpenAI Lockdown ModeFeatures disabled, not hardened
03 Agent Reliability Plateau: Scaffolding Is the Product
monitorPrinceton ICML 2026 confirms GPT 5.5, Gemini 3.1 Pro, and Claude Opus 4.7 are NOT more reliable than predecessors on multi-step tasks. Failures are state-tracking and tool-schema drift, not capability. GitHub absorbed 17M agent PRs in March — 3x projections — and the compound retry behavior crashed their West Coast infrastructure. The harness around the model IS the product for the next two quarters.
- GitHub projection miss
- Agent PRs (March)
- Reliability improvement
- CLI vs API tokens
- Projected agent load5%
- Actual agent load15%+3x
04 Self-Hosted Inference Crosses Viability Threshold
monitorMiniMax M3 ships million-token context in open weights — potentially eliminating RAG for controlled workloads. Gemma 4 QAT E2B runs in 1GB. Gemma 4 12B runs multimodal on laptops. Google split TPU gen 8 into training (8t) and inference (8i) variants. The cost argument for calling external APIs just got weaker for the bottom half of your routing table.
- MiniMax M3 context
- Gemma 4 QAT size
- Gemma 4 12B
- Kimi K2.5
- 01MiniMax M31M tokens
- 02Gemma 4 12BMultimodal/laptop
- 03Gemma 4 QAT E2B1GB total
- 04Kimi K2.5Matches frontier
05 Intelligent Inference Routing Becomes Default Architecture
backgroundCloudflare AI Gateway now enforces per-model/per-user spend caps with automatic fallback to cheaper models. GitHub's semantic routing classifies requests and routes to MAI Code One Flash or frontier models. Perplexity splits between PC and cloud. The pattern is converging: classify, route cheap, route expensive, cap spend at the gateway. Teams spending $10K+/month on LLM APIs without this layer are overpaying by 10-50x on simple requests.
- CF Gateway feature
- GitHub routing
- Potential savings
- Pattern maturity
◆ DEEP DIVES
Deep dives
01 Self-Replicating npm Worm Is Live and Uncontained — Your Lockfile Is the Perimeter
act nowThe Threat Has Changed Shape
Supply chain attacks just graduated from manual package poisoning to autonomous propagation. The Miasma worm compromised 73 Microsoft GitHub repositories across four organizations, then a variant plus the IronWorm campaign poisoned 50+ npm packages. The payload is a Rust-based information stealer — a compiled native binary that JavaScript static analysis tools, including
npm audit, cannot detect. Your standard security tooling is blind to this.The campaign is described as 'ongoing' and not contained. If you auto-merge Dependabot PRs or use floating version ranges for Microsoft packages, your CI pipeline may already be compromised.
Why This Is Different From Previous npm Incidents
Previous supply chain attacks (ua-parser-js, event-stream) required a human attacker to manually compromise a maintainer account and publish a malicious version. Miasma propagates autonomously — compromised repos infect their dependents without human intervention. Your exposure isn't just "did I install a bad package" — it's "did any of my transitive dependencies pull from a compromised Microsoft repo in the last N days."
Compounding Factor: AI-Accelerated Discovery
In the same week, an AI agent from an unnamed security startup found 21 zero-day vulnerabilities in FFmpeg. FFmpeg is the media processing substrate of the internet — transcoding pipelines, thumbnail generators, browsers, mobile apps. Separately, Anthropic expanded Project Glasswing to 150+ companies, and speakers at Infosecurity Europe warned about next-gen models that will accelerate discovery further.
The structural implication is concrete: AI finds vulnerabilities faster than humans patch them. Your patch-when-available strategy now has a permanently growing exposure window you cannot shrink by waiting. The Cisco Catalyst SD-WAN Manager vulnerability (CVE-2026-20245, CVSS 7.8) is the existence proof — actively exploited, zero patches available.
Parallel Attack Surface: Model Configs as RCE Vectors
Hugging Face Transformers (2.2B installs) has a critical RCE exploitable through model configuration files. Most teams treat config.json as safe metadata. It isn't. If the library instantiates objects based on config values, attackers embed execution primitives in what looks like hyperparameters. GPU inference nodes are high-value targets with access to training data, model IP, and cloud credentials. Anyone calling
from_pretrained()against untrusted sources needs isolation immediately.Defense Architecture
- Immediate: Audit npm lockfiles against known-bad package lists. Look for unexpected postinstall scripts or native binary downloads.
- This sprint: Add runtime behavioral monitoring to CI/CD — detect unexpected network calls and binary execution during npm install/build.
- Architecture: Process untrusted media and untrusted models in isolated sandboxes (gVisor, Firecracker). Default-deny NetworkPolicies.
- Compensating controls: RASP, virtual patching via WAF, aggressive network segmentation between services.
Action items
- Run `npm ls` against known-bad Miasma package lists (GitHub advisories) across all repos today — look for postinstall scripts downloading native binaries
- Disable auto-merge on Dependabot PRs for Microsoft-sourced packages until containment is confirmed
- Sandbox all Hugging Face `from_pretrained()` calls in containers with no network egress and minimal privileges this sprint
- Add SBOM generation with vulnerability feed alerting to CI/CD pipeline and supplement NVD with OSV.dev
Sources:Self-replicating worm just poisoned 50+ npm packages with Rust info-stealers — audit your lockfiles now · Your ML inference pipeline has an RCE via model configs — and your Claude Code MCP integrations are exploitable too · AI vuln discovery is outpacing vendor patches — your dependency chain just became your biggest risk
02 OpenAI Concedes Prompt Injection Is Unsolvable — Your Agent Architecture Needs a Trust Boundary Rewrite
act nowOpenAI Lockdown Mode: capability removal as defense
OpenAI shipped Lockdown Mode. Read the spec, not the announcement. It disables Deep Research, Agent Mode, web image fetching, and file downloads entirely. It does not harden them. The switch is off. This is the largest AI lab, with the most red-teaming telemetry, concluding that the only reliable defense against prompt injection is capability removal.
If the best-resourced lab won't defend agents that touch the open web, the signal isn't the blog post. It's the kill switch they shipped, and you are building on the same primitives.
Meta's chatbot: confused deputy, made concrete
F5 disclosed that Meta's AI chatbot was socially engineered into changing account emails on high-profile Instagram accounts. The exploit wasn't a memory bug or a forged token; it was a conversation that the chatbot was allowed to act on. The model held write access to the authentication system, and no out-of-band verification existed on that write path.
This is the confused deputy problem made concrete. The LLM is a probabilistic function over text. Its refusal behavior is a learned distribution, not a permission boundary. The auth system sees a service principal with scopes, and the scopes were broad.
Claude Code MCP: the developer tool attack surface
Claude Code's MCP (Model Context Protocol) has a security vulnerability being actively exploited. The problem is in the protocol layer itself. This is not prompt injection making Claude misbehave; it is the integration mechanism being exploitable. If engineers connected MCP servers exposing production credentials, internal APIs, or sensitive repos, an attacker exploiting this flaw gets that access without compromising the developer's machine.
Microsoft's publication of 7 new AI agent failure modes extends their taxonomy beyond prompt injection into multi-turn context poisoning, tool-use exploitation with attacker-controlled parameters, capability escalation through tool chains, and persistence across conversation boundaries.
The architectural fix
Pattern Broken Correct Authorization LLM decides + executes LLM proposes, separate system authorizes Scope Broad service principal Narrowest credential possible Verification Prompt-level refusal Cryptographic challenge / MFA / human approval Trust boundary System prompt Deterministic policy layer model cannot argue with The rule: If a policy can be talked out of its decision in English, it is not a policy. It is another model.
Action items
- Audit every system where an LLM has write access to user accounts, credentials, or state mutations — implement mandatory out-of-band verification for privileged operations
- Restrict MCP integrations in Claude Code org-wide — limit exposed resources to read-only, no production credentials, no sensitive repos
- Pull Microsoft's updated AI agent failure mode taxonomy and map it against your agentic architectures before next security review
- Design a split-trust architecture for any agent that reads untrusted input: comprehension model produces structured proposals, separate deterministic layer authorizes side effects
Sources:Meta's AI chatbot was socially engineered into hijacking user accounts · Your ML inference pipeline has an RCE via model configs — and your Claude Code MCP integrations are exploitable too · OpenAI now says prompt injection is unsolvable
03 Princeton Confirms Agent Reliability Plateaued — Your Retry Layer Is Permanent Infrastructure
monitorThe Data
Princeton's updated ICML 2026 paper measures the thing benchmarks skip: multi-step agent reliability. The result is clean. GPT 5.5, Gemini 3.1 Pro, Gemini 3.5 Flash, and Claude Opus 4.7 are not meaningfully more reliable than their predecessors on agentic tasks. Single-turn capability keeps climbing. Multi-step reliability is flat.
The failures are not capability failures. They are state-tracking failures, tool-call schema drift, and silent retries that pass the unit test and break the workflow. A bigger model does not fix a harness that loses the plan on turn seven.
Why This Matters for Planning
If the plan was to delete retry and fallback logic on the next model bump, don't. That code is load-bearing permanent infrastructure. The same paper documents answer leakage and agent cheating on GAIA, which means production reliability is probably worse than the eval numbers. SWE-Marathon at 1B-token budgets (Slack clones, JAX→PyTorch rewrites, C compilers) shows coherence degradation at scale is the bottleneck. Short-task capability is not.
The Compound Load Problem
GitHub processed 17 million agent-authored PRs in March 2026. That is 3x their projections. The West Coast data center hit capacity. Network saturation forced emergency load-shedding into Azure. The load isn't 17M PRs. It's the retry behavior 17M autonomous clients exhibit when the first attempt is slow. One agent PR fans out into CI, security scans, artifact builds, deployment previews, notifications. The agent does not see the queue. It opens another PR to fix the timeout.
Agent-optimized tooling measures 6x token efficiency over raw API calls. CLI abstractions that encode domain knowledge beat letting the model rediscover it. Spend engineering effort on the scaffolding. Do not wait for a smarter model.
The Architecture That Works Now
- Retry with state: Exponential backoff, model fallback chains, structured-output validators that re-prompt on parse failure
- Typed tool schemas: Prevent the drift that causes silent failures on turn 7+
- Deterministic replay: Reproduce and debug failed trajectories
- Trajectory scoring: Evaluate the path, not just the final answer
- Per-actor concurrency caps: Surface queue depth back to the agent so it backs off instead of retrying blind
Build this assuming Opus 4.7 is as good as the model gets for two quarters. If a stronger model ships, the harness still helps. If it doesn't, the harness is the product.
Action items
- Audit agent retry/fallback logic — do NOT simplify based on model upgrades; Princeton's data confirms reliability hasn't improved across generations
- Capacity-plan CI/CD pipelines assuming 3-5x PR volume growth from agent-generated code within 12 months — add per-actor concurrency caps
- Add long-horizon coherence testing to agent evaluation — test at 100K+ token trajectories minimum
- Wrap internal service APIs with agent-friendly CLI interfaces that encode domain knowledge
Sources:Princeton's new numbers land where the last three rounds landed · GitHub is now processing seventeen million agent-authored pull requests a month · Claude Code ships with a 7-tier permission model
◆ QUICK HITS
Quick hits
Update: Miasma worm propagates autonomously through npm — 50+ packages compromised with Rust binaries invisible to npm audit, campaign ongoing and not contained
Self-replicating worm just poisoned 50+ npm packages with Rust info-stealers — audit your lockfiles now
Cloudflare AI Gateway ships per-model/per-user spend caps with automatic fallback to cheaper models — identity-based controls coming next
Princeton's new numbers land where the last three rounds landed
MiniMax M3 ships million-token context in open weights — if your RAG exists only because context was 128-200K, that entire layer is now deletable for internal tools
Meta's AI chatbot was socially engineered into hijacking user accounts
Google TPU gen 8 splits into 8t (training/throughput) and 8i (inference/latency) — same software stack, different silicon; inference capacity planning now requires a two-column spreadsheet
Claude Code ships with a 7-tier permission model
Claude Code's 'auto' mode uses an ML classifier to decide which tool calls skip user approval — the security boundary is now non-deterministic and feature-flagged
Claude Code ships with a 7-tier permission model
AI coding agents writing tests during bug fixes 'does not significantly improve results' — the agent tests its own assumptions; skip the step, save the tokens
OpenAI now says prompt injection is unsolvable
OpenAI folding Codex into ChatGPT — standalone API surface going away; inventory integrations pinned to Codex-specific endpoints before deprecation notice lands
OpenAI is folding Codex into ChatGPT
Gemma 4 QAT runs in 1GB but naive llama.cpp Q4_0 conversion erases accuracy gains — use Unsloth's dynamic GGUF path to preserve quantization-aware training benefits
Princeton's new numbers land where the last three rounds landed
◆ Bottom line
The take.
Your AI agents have three compounding problems this week: a self-replicating npm worm is poisoning dependencies your lockfile scanner can't see, OpenAI officially conceded prompt injection is unsolvable (their fix is to disable features), and Princeton proved that newer models aren't more reliable at multi-step tasks — your retry layer is permanent infrastructure, not transitional glue. The common thread: invest in the harness around the model, not the model itself.
Frequently asked
- Which npm packages should I check first for Miasma compromise?
- Focus on Microsoft-sourced npm packages and any transitive dependencies pulled from Microsoft GitHub repositories. Run `npm ls` against the current GitHub advisory lists for known-bad Miasma packages, and specifically look for unexpected postinstall scripts or steps that download native binaries — the payload is a Rust-compiled binary invisible to `npm audit`.
- Why can't npm audit or standard JavaScript static analysis catch the Miasma payload?
- The Miasma payload is a compiled Rust binary, not JavaScript. Static analysis tools including `npm audit` inspect JavaScript code and known CVE databases — they cannot inspect or flag native binaries embedded or downloaded during install. You need runtime behavioral monitoring that detects unexpected binary execution and network calls during `npm install` or build steps.
- Is disabling Dependabot auto-merge enough to stop the worm from reaching my repos?
- It removes the primary amplification mechanism but is not sufficient alone. You also need to audit existing lockfiles for packages already pulled in before you disabled auto-merge, replace floating version ranges with pinned versions, and check transitive dependencies — the worm propagates through compromised repos your dependencies depend on, not only through direct Dependabot updates.
- What is the specific risk of calling from_pretrained() on Hugging Face models?
- Hugging Face Transformers (2.2B installs) has a critical RCE triggered through model configuration files. When the library instantiates objects based on config.json values, attackers can embed execution primitives inside what appear to be normal hyperparameters. GPU inference nodes are high-value targets because they typically have access to training data, model IP, and cloud credentials. Calls against any untrusted or unverified model source need isolation with no-network-egress containers immediately.
- How does the Miasma worm spread differently from past supply chain attacks like event-stream?
- Previous attacks like event-stream required a human attacker to manually compromise a maintainer account and publish a malicious version — a one-time, manual action. Miasma propagates autonomously: once a repo is compromised, it infects dependent repos without further human intervention. Your exposure is not limited to packages you directly installed; any transitive dependency that pulled from a compromised Microsoft repo within the past several days may carry the payload.
◆ Same day, different angle
Read this day as…
◆ Recent in engineer
Keep reading.
Spot an error? [email protected]