Cursor and Argo CD Hit With Critical RCEs, No Argo Patch Yet

NVIDIA TwoTower, vLLM DSpark, and TDT's skip-prediction pattern

Three independent inference breakthroughs landed in a single cycle. Each is deployable now or within weeks. Together they compound with multi-model routing to fundamentally change your serving cost model.

1. NVIDIA TwoTower: 2.42× Generation, 98.7% Quality

The architecture: split a 30B model into a frozen context encoder and a separately-trained writer that generates tokens in parallel via diffusion-style decoding. Key engineering insight: you don't retrain from scratch — freeze the context model, train only the writer. This makes it a viable retrofit for existing deployments.

Trade-off: you need both models loaded simultaneously (higher memory). But memory is cheaper than latency for most serving scenarios. Don't adopt yet — monitor for framework support in vLLM/TGI.

2. vLLM DSpark: 250 tok/s on DeepSeek (8×B300)

vLLM landed native DSpark speculative decoding for DeepSeek models. GLM-5.2 DSpark preview claims 1.5× faster decode. The dflash drafter on Qwen3-32B yields ~50% higher throughput on identical hardware. These are immediately deployable for anyone self-hosting.

3. TDT: Learn to Skip Sequential No-Ops (ASR, but generalizable)

Token-and-Duration Transducer adds a single output head that predicts how many frames to skip, eliminating ~80% of compute wasted on blank predictions in sequential models. NVIDIA's Parakeet TDT leads HuggingFace Open ASR Leaderboard on throughput. Speechmatics achieves 1.07% WER on voice agent benchmarks with TDT in production.

The generalizable pattern: when you have a sequential process where most iterations produce trivial outputs, teach the model to predict how many steps to skip.

The Compounding Effect

These speedups layer on top of the routing architecture. Factory AI's production data shows open-source models handle ~60% of coding token spend. Combined: route 60% of requests to self-hosted models running DSpark (250 tok/s), serve the remaining 40% frontier requests via token-level routing (Weave's pattern: frontier for hard planning tokens, open-source for boilerplate completion within the same response).

The Hidden Cost: Agentic Token Overhead

A single agent turn that looks like a 500-token response may consume 15,000 tokens across reasoning chains, failed tool calls, retrieval round-trips, and speculative decoding. Your cost models are underestimating by potentially 5-10×. Implement per-category token observability: input, output, reasoning, cached, speculative, retrieval, tool-use tokens — each with different cost characteristics.

Inner loop executes. Outer loop maintains. Get the boundary wrong and nothing gets caught.

AIEWF's Day 3 named a pattern I've watched teams reinvent for a year: autoresearch. Outer-loop agents that observe, study, and maintain the inner-loop systems doing the work. Multiple sources landed on it independently. This is not monitoring bolted onto execution. It is a separate control plane.

The Architecture

The production agent does work in the inner loop. A meta-agent watches it in the outer loop. It catches output drift, behavioral degradation, and semantic changes that latency and error-rate dashboards never see. Here is the failure I keep finding in code review: observability wired into the execution loop. Wrong loop. Guardrails, checkpoints, and human intervention points belong on the outer loop.

If the vendor describes their own system as something they 'figure out and learn with as they use it,' the model API is not a stable contract. Every version bump is a potentially breaking semantic change.

Agent Memory: From Retrieval to Reconciliation

The memory layer is moving past 'stuff everything in a vector store' toward reconciliation with actual write semantics:

• Weaviate Engram: extract candidate memories, transform against existing state, resolve contradictions, commit. MVCC for agent knowledge.
• LangChain OpenWiki: generate structured, agent-consumable documentation upfront. Less runtime retrieval.
• Pinecone Nexus: pre-compiled task artifacts. The agent loads pre-computed plans instead of searching at runtime.

Three vendors, one diagnosis: naive RAG over accumulated agent memories drifts into contradiction and degrades. Spend on the write path. The read path is not where you're losing.

Practical Implications

Anthropic says models are 'grown not developed.' Take that literally. Test behavioral contracts in CI. Not 'does the API return 200.' Test whether the model still refuses unsafe requests the same way, still follows the system prompt with the same fidelity, still produces outputs inside expected semantic bounds. Most teams skip this. Then a Thursday model update quietly rewrites their agent's personality and no test goes red.

The Agentic MapReduce Pattern

Cognition's Devin Security Swarm proved it at scale. Fan out bounded agents, each scoped small enough to fit in context without retrieval. Aggregate the findings. Validate independently. It found 1,000+ vulnerabilities in a Fortune 500's production repos. The same shape covers tech debt inventory, API contract validation, dependency upgrade impact, and compliance checking. The 'bounded' constraint removes the RAG accuracy problem entirely. That is the part I'd copy first.