Engineer daily

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,663
Read
8min

Topics Agentic AI LLM Inference AI Capital

◆ The signal

It propagates autonomously across repositories and is not contained. If your CI/CD auto-merges Dependabot PRs or uses floating version ranges for Microsoft packages, stop and audit your lockfiles now — your npm audit is blind to compiled native binaries in postinstall scripts.

◆ INTELLIGENCE MAP

Intelligence map

  1. 01

    Self-Replicating Supply Chain Worm + AI-Accelerated Vuln Discovery

    act now

    Miasma worm hit 73 Microsoft GitHub repos and 50+ npm packages using Rust binaries invisible to JS static analysis. Separately, an AI agent found 21 FFmpeg zero-days in one pass. Patch velocity requirements are about to spike 5-10x as AI discovery tools get pointed at every foundational C/C++ library.

    73
    Microsoft repos compromised
    3
    sources
    • npm packages poisoned
    • FFmpeg zero-days found
    • Cisco SD-WAN CVSS
    • Campaign status
    1. MS GitHub repos73 repos
    2. npm packages50+
    3. FFmpeg 0-days21 CVEs
    4. MS orgs affected4 orgs
  2. 02

    AI Systems Are Now the Attack Surface: Meta, HuggingFace, MCP, Lockdown Mode

    act now

    Four independent disclosures this week confirm AI tooling is a first-class attack surface. Meta's chatbot hijacked accounts via social engineering (no memory exploit needed). HuggingFace Transformers has RCE via model configs. Claude Code MCP protocol is exploitable. OpenAI shipped Lockdown Mode — disabling features entirely because prompt injection is unsolvable.

    2.2B
    HuggingFace installs exposed
    4
    sources
    • HF Transformers installs
    • MS agent failure modes
    • OpenAI's fix
    • Meta exploit vector
    1. Meta chatbotAccount takeover via chat
    2. HuggingFaceRCE via model config files
    3. Claude Code MCPProtocol-level exploit
    4. OpenAI LockdownDisables Agent Mode entirely
  3. 03

    Agent Reliability Plateau: Scaffolding Is the Product, Not the Glue

    monitor

    Princeton's ICML 2026 study confirms GPT 5.5, Gemini 3.1 Pro, and Claude Opus 4.7 are NOT more reliable than predecessors on multi-step agent tasks. Single-turn capability climbs; multi-step reliability stays flat. The bottleneck moved from weights to scaffolding. GitHub absorbed 17M agent PRs in March — 3x projections — saturating West Coast infrastructure.

    17M
    agent PRs per month
    3
    sources
    • Agent PR volume
    • vs. projection
    • Reliability gain
    • Tool efficiency gain
    1. Single-turn capability92%+15%
    2. Multi-step reliability47%+2%
  4. 04

    Self-Hosted Inference Crosses the Viability Threshold

    monitor

    MiniMax M3 ships open-weight with 1M-token context. Gemma 4 QAT runs in 1GB. Gemma 4 12B runs multimodal on a laptop. Kimi K2.5 and GLM-5 match closed models on agentic benchmarks. The context-window reason to call out to a vendor is weaker this week. The intelligent routing pattern — local for cheap/private, cloud for hard — is now the default architecture.

    1GB
    Gemma 4 QAT footprint
    3
    sources
    • MiniMax M3 context
    • Gemma 4 QAT size
    • Gemma 4 12B
    • CF Gateway savings
    1. 01MiniMax M31M context, open-weight
    2. 02Gemma 4 QAT E2B1GB, on-device
    3. 03Gemma 4 12BMultimodal, laptop
    4. 04Kimi K2.5Agentic parity
    5. 05GLM-5Tool-use parity
  5. 05

    OpenAI Codex Folding Into ChatGPT — Deprecation Timer Started

    background

    OpenAI is merging Codex into ChatGPT as a unified product. The standalone Codex API surface is going away. Auth flows, rate limits, and model behavior will change. Completion-style callers break first. Teams with CI lint bots, PR review hooks, or IDE plugins calling Codex by name have a ~12-month migration window that starts now.

    ~12mo
    deprecation window
    2
    sources
    • Migration window
    • Break risk
    • Also pivoting

◆ DEEP DIVES

Deep dives

  1. 01

    Miasma Worm: Your npm Lockfile Is Under Active Autonomous Attack

    act now

    What Happened

    A self-replicating supply chain worm called Miasma has compromised 73 Microsoft GitHub repositories across four organizations and poisoned 50+ npm packages. A variant campaign (IronWorm) added to the total. The payload is a Rust-based information stealer — a compiled native binary that won't appear in JavaScript static analysis. Your npm audit is blind to this.

    The attack pattern isn't '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.' The campaign is ongoing and not contained.

    Why This Is Qualitatively Different

    Previous supply chain attacks (typosquatting, maintainer takeover) required manual per-package effort. Miasma propagates autonomously — compromised repos infect their dependents without human intervention. This is a worm, not a poisoning campaign. Combined with IronWorm using a similar technique, the blast radius is expanding faster than the security community can map it.

    The FFmpeg Amplifier

    Simultaneously, an AI agent from an unnamed security startup discovered 21 zero-day vulnerabilities in FFmpeg's C codebase in a single pass. FFmpeg is the media processing substrate of the internet — video transcoding, thumbnail generation, browser media handling, mobile apps. If you accept user-uploaded media anywhere, you're exposed. This signals a structural shift: AI-powered vulnerability discovery is now production-real, and similar agents are being pointed at ImageMagick, libxml2, OpenSSL, and zlib. Expect patch velocity requirements to spike 5-10x.

    Detection Gap

    The Rust binary distribution through npm is specifically designed to evade the tools most teams rely on. JavaScript-based static analysis sees nothing. The attack surfaces via postinstall scripts that download native binaries or trigger unexpected network connections during npm install. CI/CD pipelines that auto-merge Dependabot PRs or use floating version ranges are the highest-risk exposure.


    Compensating for the Structural Patch Gap

    Multiple sources confirm AI vulnerability discovery is now structurally outpacing vendor patch capacity. Anthropic's Project Glasswing expanded to 150+ companies. The architecture response is defense-in-depth: process untrusted inputs in isolated sandboxes (gVisor, Firecracker microVMs), enforce NetworkPolicies that default-deny, and treat your dependency chain as partially compromised at all times.

    Action items

    • Run `npm ls` against known-bad package lists (GitHub advisories) and grep for unexpected postinstall scripts or native binary downloads in all recently-updated dependencies
    • Disable auto-merge on Dependabot PRs for any Microsoft-org-sourced packages until the campaign is contained
    • Add runtime behavioral monitoring to CI/CD that detects unexpected network calls and native binary execution during npm install/build phases
    • Inventory all FFmpeg usage (direct and transitive) and ensure media processing runs in sandboxed environments with no network egress
    • Add SBOM generation to CI/CD and wire to OSV.dev + GitHub Advisory Database (supplement NVD, which has an acknowledged growing backlog)

    Sources:Self-replicating worm just poisoned 50+ npm packages with Rust info-stealers — audit your lockfiles now · AI vuln discovery is outpacing vendor patches — your dependency chain just became your biggest risk

  2. 02

    AI Systems Are the Attack Surface Now — Four Disclosures Confirm the Pattern

    act now

    The Pattern

    Four security disclosures this week, four different surfaces, one shared property: AI tooling is a first-class attack surface and the tooling around it has not caught up. Dependency scanners do not parse model configs. They do not understand MCP. They do not model agent failure. AppSec, as currently shipped, does not cover this code path.

    SystemAttack VectorImpactFix
    Meta AI ChatbotSocial engineering via conversationAccount email takeoverOut-of-band verification on write ops
    HuggingFace TransformersRCE via model config.jsonGPU node compromise + lateral movementSandbox from_pretrained(), minimal privileges
    Claude Code MCPProtocol-level exploitAccess to dev environment resourcesRestrict MCP servers, read-only, no prod creds
    OpenAI (Lockdown Mode)Prompt injection (acknowledged unsolvable)Data exfiltration via agentsDisable Deep Research + Agent Mode entirely

    The Meta Exploit Is the Archetype

    The Meta AI chatbot was talked into changing account emails. No memory corruption. No forged token. The model had write access to the identity system and someone asked nicely. This is the confused deputy, dressed up. An LLM is a probabilistic function over text. It is not an access control boundary. Wiring refusal behavior to permission decisions is a type error in production.

    If the policy can be talked out of its decision in English, it is not a policy. It is another model.

    HuggingFace: Config Files Are Code

    HuggingFace Transformers ships with 2.2 billion installs. It is in the stack. The RCE targets configuration files, not weights. Most teams parse config.json as inert metadata. The library instantiates objects from those values, which means an attacker writes execution primitives into fields that look like hyperparameters. GPU inference nodes are the prize: training data, model IP, cloud credentials, lateral movement off the ML subnet.

    OpenAI's Concession

    Lockdown Mode disables Deep Research, Agent Mode, web image fetching, and file downloads entirely. It does not harden them. Read the spec carefully. The best-funded lab, with the most red-team data anyone has, shipped a feature whose mechanism is capability removal. That is the concession. Prompt injection is not being solved at the model layer. If you ship an agent that ingests untrusted content and holds tool-calling permissions, you own the exact failure mode OpenAI just declined to fix.

    Microsoft's 7 New Agent Failure Modes

    Microsoft extended their AI agent failure taxonomy with 7 new categories past prompt injection. The likely set: multi-turn context poisoning, tool-use exploitation, capability escalation through tool chains, persistence. Pull the taxonomy. Map it against the agent architectures already in production before the next security review, not after.

    Action items

    • Audit every system where an LLM has write access to user accounts, credentials, or state mutations — implement mandatory out-of-band verification (MFA, separate service, human approval) for all privileged operations
    • Sandbox all HuggingFace from_pretrained() calls in containers with minimal privileges and no network egress — audit model config loading paths for untrusted sources
    • Restrict Claude Code MCP integrations org-wide: limit exposed resources, enforce read-only access, remove production credentials from MCP servers
    • Pull Microsoft's updated AI agent failure mode taxonomy and run a threat modeling session against your agentic architectures

    Sources:Your ML inference pipeline has an RCE via model configs — and your Claude Code MCP integrations are exploitable too · Meta's AI chatbot was socially engineered into hijacking user accounts · OpenAI now says prompt injection is unsolvable · Princeton's new numbers land where the last three rounds landed

  3. 03

    Agent Reliability Has Plateaued — Your Scaffolding Is Permanent Infrastructure

    monitor

    Princeton Put a Number on It

    Princeton's updated ICML 2026 paper confirms what production traces have been showing for a year. GPT 5.5, Gemini 3.1 Pro, and Claude Opus 4.7 are not meaningfully more reliable than their predecessors on multi-step agentic tasks. Single-turn benchmarks keep climbing. Multi-step reliability is flat. The traces show why: state-tracking drops, tool-call schema drift, and silent retries that pass unit tests while breaking the workflow downstream.

    A bigger model does not fix a harness that loses the plan on turn seven. The bottleneck moved from weights to scaffolding sometime in the spring. Princeton has now put a number on it.

    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 and emergency load-shedding pushed traffic into Azure. The interesting load is not the 17M. It is the retry behavior of 17M autonomous clients when the first attempt is slow. An agent that does not know about a queue opens another PR to fix the timeout. That PR queues behind the first one.

    CI/CD was designed for developers who go get coffee between pushes. It was not designed against autonomous clients that retry blind on slow responses. This pattern arrives in 6-12 months for anyone running agents in the loop.

    The Routing Pattern That Survived

    The intelligent routing architecture is unglamorous and now validated at scale:

    1. Classify the request by complexity. Rule-based heuristics first, trained classifier later.
    2. Route cheap and simple requests to Gemma 4 QAT on hardware you own.
    3. Route hard requests to frontier models with the retry layer intact.
    4. Put a gateway in front. Cloudflare AI Gateway now supports this. Kill anything exceeding the per-route budget.

    GitHub's 'auto' setting runs a classifier on incoming requests and routes to the cheapest capable model. MAI Code One Flash takes simple completions. Opus and GPT take multi-file refactors. The hard part is the classifier: sub-10ms latency, accurate enough not to garbage easy requests or choke hard ones.

    Claude Code's Permission Model as Reference Architecture

    Claude Code shipped a 7-tier permission system: enterprise policy, command-line flags, local project settings, shared project settings, user settings, session grants, default deny. The mechanism worth copying is 'bubble' mode. Subagents escalate to their parent agent, not directly to the user. This is UNIX process privilege inheritance for AI. Building multi-agent orchestration means the same primitives: what a spawned agent inherits, what requires explicit delegation, what is denied regardless.

    The 'auto' Mode Warning

    In 'auto' mode, an ML classifier decides per-call whether to ask the user. The security boundary is now non-deterministic. The classifier's false negative rate is part of the threat model. Anthropic knows this. 'auto' is feature-flagged and not user-selectable yet.

    Action items

    • Do NOT simplify agent retry/fallback logic based on model upgrades — Princeton confirms reliability hasn't improved across generations. Keep exponential backoff, model fallback chains, and structured-output validators.
    • Audit CI/CD pipeline capacity assuming 3-5x PR volume growth from agent-generated code within 12 months — add per-actor concurrency caps and queue depth surfacing
    • Implement semantic routing in your LLM integration layer: route by complexity to cheapest capable model, start with rule-based heuristics (token count, multi-file refs, complexity keywords)
    • Add long-horizon coherence testing (100K+ token trajectories) to agent evaluation suites — score trajectories, not final answers

    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

  4. 04

    Self-Hosted Inference Just Crossed the Viability Line — Re-read Your Build-vs-Buy

    monitor

    The Context Window Reason to Call a Vendor Is Weaker This Week

    Three releases landed in the same week. Together they change the self-hosted inference calculation.

    • MiniMax M3: Million-token context window, open weights. If a RAG pipeline exists only because context was 128K to 200K, a million tokens potentially deletes that entire layer.
    • Gemma 4 QAT E2B: Runs in roughly 1GB. On-device classification, summarization, and simple generation are practical on commodity hardware now.
    • Gemma 4 12B: Multimodal on a laptop. Code review assistants and screenshot-to-code flows on local hardware. Zero API cost. Zero exfiltration risk.

    Open-weight models (Kimi K2.5, GLM-5) now match closed models on agentic benchmarks. Sparse MoE (Qwen3.5) is the dominant efficiency architecture. Activating a subset of parameters per token buys a larger effective model at lower compute cost.

    The Quantization Trap

    One implementation detail bites teams that don't check. Convert QAT checkpoints to llama.cpp's Q4_0 naively and you erase the accuracy gains QAT was designed to preserve. The conversion doesn't respect the quantization grid the model trained against. Unsloth's dynamic GGUF path handles this correctly. Standard conversion scripts do not. The difference between 'quantization works' and 'quantization destroys accuracy' is the conversion path, not the technique.

    Cloudflare AI Gateway: Cost Control at the Edge

    Cloudflare's AI Gateway now enforces per-model and per-user spend caps with automatic fallback to cheaper models when caps trip. Identity-based controls via Cloudflare Access are next. The math is straightforward. Routing 10% of a $10M annual inference bill from frontier to cheaper tiers saves about $1M. The architecture is a model load balancer with cost awareness. It degrades gracefully instead of failing on overspend.

    Google TPU 8t/8i Split

    Google now ships two TPU SKUs. 8t is throughput-optimized for training. 8i is latency-optimized for inference. Same Axion CPU host, same liquid cooling, same JAX software stack. The hardware diverges. The developer surface doesn't. Sizing inference capacity on GCP is now a question of mix between 8t and 8i, with separate utilization models for each.

    The gap to hosted frontier models is not closed, but it is close enough that the self-hosted inference plan from six months ago is worth re-reading. Specifically: the part where the context window was the reason to call out to a vendor.

    Action items

    • Run cost-per-token comparison: current OpenAI/Anthropic spend vs. MiniMax M3 or Gemma 4 12B self-hosted for your top 3 internal tooling workloads
    • Test Gemma 4 QAT E2B via Ollama/vLLM for lightweight inference tasks — use Unsloth's dynamic GGUF path, NOT standard Q4_0 conversion
    • Evaluate Cloudflare AI Gateway spend limits for your inference routing layer, especially per-model/per-user budget enforcement with automatic fallback
    • Prototype a hybrid inference router classifying by data sensitivity, task complexity, latency budget, and dollar budget — route local vs. cloud

    Sources:Meta's AI chatbot was socially engineered into hijacking user accounts · Princeton's new numbers land where the last three rounds landed · Claude Code ships with a 7-tier permission model

◆ QUICK HITS

Quick hits

  • OpenAI merging Codex into ChatGPT — standalone API surface going away, ~12-month deprecation window. Inventory every integration calling Codex by name (CI bots, IDE plugins, PR hooks) and pin model versions now.

    OpenAI is folding Codex into ChatGPT

  • AI coding agents writing tests during bug fixes doesn't improve outcomes — the agent tests its own assumptions, not the spec. Skip the step, save the tokens, have a different agent or human write tests against the spec.

    OpenAI now says prompt injection is unsolvable

  • Google paying SpaceX $920M/month for data center capacity — $11B/year in opex signals GPU scarcity severe enough that hyperscalers rent from a launch company. Factor into 2027 capacity planning.

    Google is reportedly paying SpaceX nine hundred and twenty million dollars a month for data center capacity

  • Cisco Catalyst SD-WAN Manager has an actively exploited CVSS 7.8 vulnerability (CVE-2026-20245) with zero patches available — if in your infra, segment immediately and treat management plane as compromised.

    Self-replicating worm just poisoned 50+ npm packages with Rust info-stealers — audit your lockfiles now

  • Multi-tenant isolation in AI inference platforms is failing — speculated Anthropic cross-tenant output exposure plus meta-agents attempting ground-truth exfiltration. KV cache sharing and batched inference create channels that don't exist in traditional request-response.

    Princeton's new numbers land where the last three rounds landed

  • Apple WWDC Monday (Jun 9) — Tim Cook's final keynote, revamped Siri architecture expected. If you ship on iOS, assign someone to watch developer tracks for new on-device AI APIs same day.

    Google is reportedly paying SpaceX nine hundred and twenty million dollars a month for data center capacity

◆ Bottom line

The take.

Your AI tools are now attack surfaces (Meta chatbot hijacked accounts via conversation, HuggingFace has RCE via config files, OpenAI admits prompt injection is unsolvable), a self-replicating worm is actively propagating through npm with payloads invisible to static analysis, and Princeton confirmed that upgrading to the latest frontier model won't fix your agent reliability — only the scaffolding around it will. Audit your lockfiles today, sandbox your model loading, and stop treating your retry layer as temporary code.

— Promit, reading as Engineer ·

Frequently asked

Why can't npm audit detect the Miasma worm payloads?
npm audit performs JavaScript-based static analysis and cannot inspect compiled native binaries. Miasma delivers a Rust-based information stealer via postinstall scripts that download or execute native binaries at install time, which are completely invisible to npm's standard tooling.
Which CI/CD configurations put my pipeline at highest risk right now?
Auto-merging Dependabot PRs and using floating version ranges for Microsoft-sourced packages are the two highest-risk configurations. Both allow the worm to propagate autonomously into your build without manual review. Disable auto-merge for Microsoft-org packages immediately and pin all version ranges.
What does the FFmpeg zero-day discovery mean for teams that handle user uploads?
An AI agent found 21 zero-day vulnerabilities in FFmpeg's C codebase in a single pass. Since FFmpeg is used for video transcoding, thumbnail generation, and media handling across virtually every stack, any service accepting user-uploaded media is exposed. Sandbox all FFmpeg processing in isolated environments with no network egress until patches are available.
How should I detect unexpected behavior during npm install if static analysis is blind?
Add runtime behavioral monitoring to your CI/CD pipeline that flags unexpected outbound network calls, native binary downloads, or non-JavaScript process execution during npm install and build phases. This behavioral layer is the only reliable detection class for this attack pattern — static analysis will not catch it.
Should I trust npm lockfiles as proof my dependencies are clean?
No. Lockfiles record resolved package versions but do not validate the content of postinstall scripts or native binaries those packages deliver. Run npm ls against current GitHub advisory lists, manually inspect postinstall hooks in recently-updated dependencies, and treat your lockfile as a starting point for investigation, not a clean bill of health.

◆ Same day, different angle

Read this day as…

◆ Recent in engineer

Keep reading.

Spot an error? [email protected]