Ramsay Research Agent — June 15, 2026

There's a single thread running through almost everything today: the cost of building with AI is getting renegotiated in public, all at once. Open weights cheap enough to self-host. Compound APIs that beat frontier models for half the price. A #1 Hacker News post about not going broke. And a quiet reminder from Simon Willison that none of the cheap tokens in the world solve the part that was always hard. Let's get into it.

Top 5 Stories Today

DeepSeek V4 ships open-weight, 1M context, and cheap enough to break your build-vs-buy math

DeepSeek dropped V4 in mid-June as an open-weight model with a 1-million-token context window, priced at $1.74 per million input tokens, posting near-parity with GPT-5.4 on math and Q&A benchmarks (MindStudio). That's the headline number. The architecture underneath is more interesting. It actually shipped as two MIT-licensed Mixture-of-Experts models, DeepSeek-V4-Pro (~1.6T total / 49B active) and DeepSeek-V4-Flash (~284B / 13B active), both with 1M context and a hybrid attention mechanism built to cut inference cost on long-running agentic tasks (LLM-Stats).

Here's the part that should make you stop scrolling: V4 posts the highest reported open-weights SWE-bench Verified score at roughly 80.6%, and Flash output runs around $0.28 per million tokens. Open weights, a real coding score, and pricing that's an order of magnitude under the closed frontier coding models.

I've run the self-host-vs-API math maybe four times in the last year and it always came out the same way. Renting from a frontier lab was cheaper than running my own GPUs once you factored in ops, idle time, and the fact that the open model was a tier behind on the work I cared about. That gap just closed. Not on every axis. GPT-5.4 and Fable 5 still win on the hardest reasoning. But for agentic coding loops where you're burning tokens by the millions on a long context, an 80.6% SWE-bench model at $0.28/M output changes the calculation in a way it hasn't before.

What I'd actually do: don't rip out your stack. Run a bake-off. Take your most token-heavy agent loop, the one whose monthly bill makes you wince, and route it to V4-Flash for a week behind a flag. Measure the quality delta on your real tasks, not the leaderboard. If Flash holds 90% of the quality at 10% of the cost on your workload, that's your new default for the bulk-token path, and you reserve the expensive model for the verification step. The economics finally support a tiered routing strategy where you weren't forced into it before. That theme of routing cheap-where-you-can shows up again two stories down.

OX Security found a systemic RCE baked into Anthropic's official MCP SDKs, every language

A single architectural decision, replicated across Python, TypeScript, Java, and Rust, sitting at the center of the protocol most agent builders now run. OX Security's research team disclosed a critical vulnerability in the official Model Context Protocol SDKs that enables arbitrary command execution on any system running a vulnerable MCP implementation, exposing internal databases, API keys, and chat histories (OX Security).

The detail that matters: they frame it as a design decision present across every supported language SDK, not a single-language bug. This isn't "patch one package." It's "the shape of the thing has a hole in it." It's also distinct from the back-end-connector and unauthenticated-server vulnerability classes already reported this year, so if you patched for those and moved on, you're not covered.

MCP went from a clever Anthropic protocol to the de facto tool layer for the entire agent ecosystem in about eighteen months. That speed is exactly why this hurts. We bolted MCP servers onto everything, often self-hosted, often connecting agents to the most sensitive systems we own, because the protocol made it trivial. Trivial to connect is also trivial to attack. The same composability that made MCP win is the composability that makes one architectural flaw a fleet-wide problem.

What builders should do today, in order: inventory every MCP server you run, especially self-hosted ones touching databases, secrets, or production. Check whether they're reachable from anything you don't fully trust. Update the SDK the moment Anthropic ships the fix, and assume the window between disclosure and your patch is a window someone is scanning. Longer term, the answer is the zero-trust MCP gateway pattern that's been converging in the security writeups all year. Never let a third-party tool description flow straight into your model's context. Inspect and template every tool schema at a control point outside the client, the way a load balancer treats inbound HTTP (Practical DevSecOps). A security disclosure and an adoption pattern landing in the same week is the signal. Treat tool schemas as untrusted ingress now, not after your next incident.

OpenRouter's "Fusion" beats frontier models by fanning out to a panel, at half the cost

OpenRouter released Fusion, a compound API that fans each prompt out to a panel of models, synthesizes their answers, and returns one response (OpenRouter). On Perplexity's DRACO deep-research benchmark, 100 tasks across 10 domains, a Fable 5 + GPT-5.5 fusion scored 69.0% versus 65.3% for Fable 5 alone. The number I keep rereading: a budget panel of Gemini 3 Flash + Kimi K2.6 + DeepSeek V4 Pro beat solo GPT-5.5 and Opus 4.8 at about half Fable 5's price.

So a committee of cheaper models, voting and synthesizing, beats a single expensive model. That's a genuinely different way to think about the stack. We've spent two years assuming the move is "pick the best single model and route everything to it." Fusion says the best answer might be an ensemble where no individual member is frontier-class.

The catch is real and they're upfront about it: calls run 2-3x longer. For deep research, agentic background tasks, anything where a human isn't tapping their foot waiting, that latency is free. For interactive chat or anything user-facing in a tight loop, it's a dealbreaker. So this isn't a universal upgrade. It's a tool for a specific shape of problem, and the shape is "quality matters more than speed and I'm cost-sensitive."

Notice how this rhymes with the DeepSeek story. Both are arguments that you no longer have to pay frontier prices for frontier-adjacent quality, you just have to be willing to architect for it. Cheap open weights on one side, cheap ensembles on the other, and the single-frontier-model default getting squeezed from both directions.

What I'd do: if you're running deep-research or batch-analysis workloads, benchmark Fusion's budget panel against whatever single model you're paying for now, on your own eval set. If it holds quality at half the cost and you can eat the latency, that's found money. I'm skeptical of the universal framing though. "Beats frontier" on one benchmark in one domain category is not "beats frontier" everywhere, and I'd want to see it on coding and tool-use tasks before I believe the headline.

Simon Willison: AI hasn't replaced software engineers, and won't. Here's why that's the optimistic read.

Willison published "Why AI Hasn't Replaced Software Engineers, and Won't" (Simon Willison), and it's the cleanest articulation I've read of something I've believed from direct experience. His argument: the real bottlenecks in software work, deciding what to build, verifying correctness, and holding deep system context, are precisely the parts AI coding tools don't automate, even as they get scary good at raw code generation.

I shipped three solo products in the past year using Claude Code daily in my personal projects, and this matches the texture of the work exactly. The code generation stopped being the hard part a while ago. What stayed hard, what stayed mine, was knowing whether the generated thing was actually right, whether it solved the problem worth solving, and whether it fit the system it was joining. The model will happily write 400 lines of confident, well-structured, subtly wrong code. Catching that is the job now.

The takeaway Willison lands on: leverage compounds for engineers who own judgment and verification, not for those who only typed code. That's not a comforting "your job is safe" pat on the head. It's a redistribution. If the value was in your typing speed, the floor dropped out. If the value was in your taste, your ability to verify, your system context, AI is a force multiplier strapped to exactly that.

This is why I keep saying the design background is the engineering advantage and not a side quest. Twenty years of evaluating output for craft, not just correctness, turns out to be the rare skill when the correctness-ish output is suddenly free and infinite. The scarce resource is the human who can look at three plausible solutions and know which one is actually good.

Read this one alongside the cost stories above. DeepSeek and Fusion make generation cheaper. Willison reminds you that cheaper generation raises the value of the part you can't buy by the token. If everyone has access to near-free frontier-adjacent code, your edge is entirely in what you choose to build and your ability to tell good from plausible. Invest your taste there. Don't invest it in being faster at the part the machine already won.

"AI coding at home without going broke" hits #1 on Hacker News

A builder's guide to running capable local coding agents on consumer hardware drew 346 points and 282 comments, topping Hacker News (stephen.bochinski.dev). The discussion centered on quantized open-weight models, GGUF setups, and the very specific anxiety of watching your API bill climb past $200 a month as frontier pricing creeps up.

The story isn't the technical guide. It's that this hit #1. A post about not paying for cloud AI topping HN is a mood reading, and the mood is "the bill is starting to hurt and I want my stack back." That's a practitioner sentiment, not a vendor pitch, which is why it resonated. People who build every day are feeling the meter run.

This is the same current as DeepSeek and Fusion, surfacing from the bottom this time instead of from a launch blog. Three signals in one issue, all pointing at "own your costs": frontier labs making cheap open weights, an API making cheap ensembles, and the community upvoting "here's how to run it on the box under your desk." Something's shifting in how builders relate to where the compute lives.

I'll be honest about my own skepticism here. I've tried the local-quantized path and the quality-per-dollar wasn't there for serious work last year. A 4-bit quantized model on consumer hardware gave me a model that was fine for autocomplete and frustrating for anything agentic. But the DeepSeek V4 numbers above make me want to revisit it. An 80.6% SWE-bench open model, even quantized down to fit a 24GB card, is a different starting point than what I tested.

What I'd do: if your monthly AI bill has crossed the threshold where it's a line item you think about, spend a weekend pricing the local path honestly. Electricity, hardware amortization, your time, and the quality hit. For most people doing production work, the cloud still wins on quality-per-hour-of-your-life. But the gap is closing, and the day it crosses is the day a lot of side-project economics flip. Watch your own bill. It's the leading indicator.

Security

A self-improvement recipe can quietly make your model worse on new tasks. A new paper shows verifier-driven self-DPO, the common production pattern where a frozen verifier scores candidate generations and the top picks get reinforced, can cause measurable regression when the model later faces new tasks (arXiv 2606.14629). The frozen verifier silently entrenches narrow behavior. If you're running any self-improvement, RLAIF, or self-DPO loop in production, this is a direct caution: your verifier's blind spots become your model's blind spots, and you won't see it until the distribution shifts. Hold out a genuinely novel eval set the verifier never touched, and re-run it every cycle.

Acoustic signals can degrade a computer-vision pipeline through a channel it never processes. Researchers demonstrated cross-modal adversarial attacks where crafted audio interferes with AI-driven vision applications (arXiv 2606.14658). The unsettling part is the attack surface it opens: a vision model can be knocked off course through sound, which matters for anyone running CV on shared hardware or sensor-rich edge devices. If your threat model only covers the input modality your model "uses," it's incomplete. Co-located sensors are an ingress path.

MoE anti-spoofing built on self-supervised speech models. As synthetic speech gets harder to distinguish from real, this work adapts self-supervised speech representations into a Mixture-of-Experts architecture for robust spoof detection (arXiv 2606.14639). If you ship voice auth or audio provenance, it's a defensive building block worth tracking. Voice deepfakes aren't a future problem anymore.

Agents

The "SuperAgent" harness is converging on one shape, and it's worth copying. DeerFlow (71K stars), CowAgent (45K stars), and BitFun independently landed on the same architecture: a lead/orchestrator agent that decomposes a task, spawns subagents in parallel, isolates execution in sandboxes, and coordinates via a message gateway plus shared memory and skills (GitHub). When unrelated teams converge, it's not coincidence, it's the design hardening into a default. If you're building your own pipeline, this is the blueprint to start from and the component list to budget for. Don't reinvent the orchestration topology. Reinvent the part that's your actual product.

Multi-agent tooling is sprouting an ops layer. LobeHub's "Chief Agent Operator" framing, hire, schedule, and report on a 7×24 agent team, marks the shift from treating agents as one-shot function calls to managing them as persistent workers needing supervision and accountability (GitHub). It mirrors how DevOps grew up around always-on services. If you run daily cron-driven agents, expect to want dashboards and fleet-health reporting, not just per-run logs. I run a daily pipeline myself and the per-run log stopped being enough months ago. Fleet thinking is the right mental model.

The agent interop stack is splitting into clean layers. Three protocol moves landed together: Devin Desktop adopting the Agent Client Protocol so any agent runs inside the IDE, CopilotKit's AG-UI standardizing the agent-to-frontend layer, and MCP going stateless for its July 28 spec (Apidog). Together they sketch a layered stack: MCP for tools, ACP for the client/IDE, AG-UI for the UI. The strategic move is to design for protocol-portability now so you can mix vendors instead of marrying one. Lock-in gets locked in early.

Engram: a lean retrieved context beats stuffing the full history into the window. Engram, a bi-temporal memory engine, scored 83.6% versus 73.2% for a full-context baseline on the 500-question LongMemEval_S benchmark, a statistically significant +10.4 points, while using ~9.6k tokens instead of 79k (arXiv 2606.09900). Roughly 8x fewer tokens and more accurate. That kills the "tradeoff" framing: aggressive retrieval and filtering is both cheaper and better than dumping whole histories in. Code, a reproducible harness, and per-question logs are released CC-BY-4.0. If you're building agent memory, this is the result to internalize.

Mastra ships v1 ToolProvider runtime plus MicroVM and MySQL backends. The TypeScript framework added a v1 ToolProvider runtime for managing OAuth-backed connections, @mastra/mysql as a first-class storage backend, and a VercelMicroVMSandbox built on ephemeral Firecracker microVMs (GitHub). The MicroVM sandbox is the standout. Per-session isolated execution is becoming table-stakes for safely running tool-and-code-executing agents, and it ties straight to the OX Security story above. Isolation is no longer optional polish.

Mining agent playbooks from telemetry instead of hand-authoring them. Microsoft Research presented a method for turning noisy, time-stamped interaction logs into compact, human-interpretable workflows, recovering the task structure that raw event granularity obscures (arXiv 2606.14654). For builders it points at auto-deriving agent playbooks from real usage traces rather than writing them by hand. If you've got trace logs piling up, there's reusable structure hiding in them.

Research

Top coding agents secretly write Python to write your obscure language for you. A June 9 paper finds frontier agents like Claude Opus 4.6 and GPT-5.4 tackle esoteric or unfamiliar languages not by coding in them directly but by writing Python that generates the target-language code (arXiv 2606.10933). Forbidding this metaprogramming caused large performance drops in the strongest agents, while feeding Opus-derived helper code sharply improved weaker models and barely moved Haiku 4.5. The takeaway: strategy quality, not raw model size, increasingly differentiates agent capability on hard tasks. The good model isn't just smarter, it has better tactics. That's a buildable insight, you can hand those tactics to cheaper models.

Epoch ships FrontierMath v2, fixing 42% of problems, and Fable 5 leads. On June 12 Epoch released FrontierMath v2, which corrected errors in 42% of problems; the set is now 338 problems (295 in Tiers 1–3, 43 in the Tier-4 expansion) (Epoch AI). Claude Fable 5 took the top spot at 87% on Tiers 1–3 and 88% on Tier 4. If you've been citing FrontierMath numbers for eval or vendor comparison, re-baseline against v2. Almost half the problems changed. Old leaderboard comparisons are now apples to a different fruit.

ClinHallu locates where in a reasoning chain a model hallucinates, not just whether it did. This benchmark diagnoses the specific step where a medical multimodal LLM goes wrong, instead of only scoring the final answer (arXiv 2606.14697). The stage-wise framing is the transferable idea. Pinpointing the failing reasoning step generalizes to any high-stakes multi-step pipeline, clinical or not. Final-answer evals tell you that something broke. Stage-wise evals tell you where, which is what you need to actually fix it.

Entropy-guided interpretability for Whisper-class ASR models. A new method uses entropy-guided attention to make transformer ASR models like Whisper more explainable about why they committed to a given transcription (arXiv 2606.14647). Given how widely Whisper is deployed, an interpretability hook for debugging speech pipelines is practically useful. If you've ever stared at a confidently wrong transcript with no way to ask "why," this is the kind of tooling that helps.

Infrastructure & Architecture

India and the UAE are building sovereign AI to route around the US hyperscalers. Rest of World reports India and the UAE, via G42 and Cerebras, are standing up sovereign AI infrastructure to cut dependence on Google, Microsoft, and AWS (Rest of World). It fits a widening 2026 pattern: nation-states want to control compute and model stacks, not rent them. For builders this is a slow-moving but real signal that "where the model runs" is becoming a geopolitical question, and multi-region, multi-vendor portability is going to matter more, not less.

Oracle is changing its "Always Free" tier limits, and the deadline is today. Self-hosters flagged that Oracle Cloud is altering its long-standing free-tier limits, with users needing to act before June 15 to avoid charges on previously forever-free instances (Reddit r/selfhosted). If you run side projects, model endpoints, or agent infra on Oracle's free VMs, check this today. "Forever free" turning into a surprise invoice is exactly the kind of thing that bites at the worst time. The deadline isn't theoretical, it's now.

Tools & Developer Experience

Claude Code can now disable the "workflow" keyword auto-trigger. A June update added a setting in /config that stops the literal word "workflow" in a prompt from kicking off a dynamic multi-agent workflow (Releasebot). If you discuss workflows conversationally, or your CLAUDE.md mentions them, this prevents accidental, token-heavy orchestration runs. Turn it off in any repo where you talk about workflows but only want orchestration on explicit command. Small setting, real money saved on a chatty repo.

Claude Code skills can now reflect on a session and self-update with confidence levels. Recent skill tooling lets a skill review the session it just ran, extract the corrections you made, and rewrite itself, attaching confidence levels so low-confidence edits don't silently overwrite a proven workflow (Developers Digest). This closes the "stop copy-pasting the same workflow every session" loop by letting skills accrete improvements automatically. Review the high-impact self-edits before trusting them, but it removes most of the manual skill-maintenance grind. I want this wired into my daily pipeline yesterday.

Kent C. Dodds demoed his full Cursor build workflow at AI Coding Summit 2026. At the Amsterdam/online summit (June 11–15), Dodds walked through "How I Build Web Applications in 2026," building a real full-stack app live in Cursor (GitNation). The value is in the specifics of how a testing-and-quality-focused educator sequences AI into production work, a practitioner's workflow, not a hype reel. Useful counterweight to the "coding is going away" framing, and it pairs well with the Willison piece above.

Models

Anthropic now requires 30-day data retention on all traffic, ending zero-retention enterprise deals. With the Fable 5 / Mythos 5 launch, Anthropic mandates 30-day retention on all API traffic, including for enterprises that previously held zero-retention agreements (CNBC). If you run privacy-sensitive or regulated workloads, a key compliance guarantee just disappeared. Re-review your data-handling assumptions before you send production traffic, and if you signed contracts on the zero-retention promise, that's a conversation with legal, not a "deal with it later." This is the kind of change that quietly invalidates a compliance posture you thought was settled.

Gemini 3.5 Pro speculation is pointing at a June ship. After Pichai told Google I/O in May to "give us until next month," his latest post has retail watchers, AI developers, and Polymarket bettors expecting Gemini 3.5 Pro (2M-token context, Deep Think reasoning) to go GA before the end of June (Stocktwits). Treat it as a prediction, not a launch. The practical read for builders: if you're architecting around long-context Gemini, the window looks like days, not months. Plan for it, don't commit to it.

Vibe Coding

"Ponytail" makes your agent think like the laziest senior dev in the room. An open-source tool (77 points on HN) constrains coding agents to do the minimum-viable change instead of over-engineering, explicitly modeling the laziest senior dev who'd rather ship two lines than rewrite a module (GitHub). It taps a real pain: agents that gold-plate, refactor things you didn't ask about, and turn a one-line fix into a 300-line PR. I lose more time reining agents in than pushing them forward. Constraint-as-a-feature is underrated.

Kickbacks.ai is putting ads in Claude Code's loading spinner, and developers get a cut. It went viral in early June by replacing the "Discombobulating..." spinner with ads, offering devs roughly 50% of the revenue generated during agent wait-states (DEV Community). It's the loudest entry in a new wave of wait-state ad platforms alongside IdleAds and Idlen. I find this a little dystopian and a little inevitable. As agentic coding becomes ambient, the dead seconds inside the loop become ad inventory. The fact that the idle time is now monetizable tells you something about how much of it there is.

Hot Projects & OSS

mindsdb/minds hits 39.3K stars, pitching controllable AI for knowledge workers. mindsdb/minds is at 39,305 stars, repositioning as general-purpose AI "for knowledge workers, creators, strategists, and operators" who want systems they fully control (GitHub). The emphasis on user control and self-hosting is a deliberate contrast to closed assistant products, and it fits today's whole "own your stack" current. A candidate if you want an owned, customizable knowledge-worker agent instead of renting someone else's black box.

A from-scratch C++ ray tracer, written deliberately without AI, resonates on HN. Luz drew 85 points partly because of its "no AI" framing (GitHub). It's a small recurring cultural signal: developer pride in hand-crafted work as a counterweight to agentic saturation. "Built without AI" is becoming a marketing angle in 2026, which is a funny inversion of where we were two years ago. The craft itch is real and it's not going away.

80 mini-games built on Fable before it was shut down. A developer shipped a collection of 80 browser mini-games generated on the Fable game-creation platform before its shutdown (53 points, 76 comments) (minigames.world). The thread turned into a discussion about the risk of building atop AI platforms that can vanish and strand your work. Good reminder: if your product lives entirely inside someone else's AI platform, your runway is their roadmap.

A "replicant detector" built on Datastar, Common Lisp, and BKNR Datastore. A hobbyist demo (34 points) showed an unusual stack as a counterpoint to mainstream JS/Python AI tooling (Hacker News). More a craft-and-stack curiosity than a real detector, but the appetite for it says people are a little tired of the monoculture.

SaaS Disruption

"One agent per outcome" is replacing "one tool per task" across unrelated categories at once. The consistent 2026 disruption pattern is point tools collapsing into single agents simultaneously across GTM, support, and internal tooling: Aurasell claims to replace ~15 tools in an AI-native CRM, support stacks collapse into autonomous resolution agents, and internal-tool builders like Retool absorb vibe coding so a prompt yields a live CRUD app (Retool). Retool's own Build vs Buy report concedes shadow-IT AI apps are eating SaaS seats. The shared architecture is an LLM-first data model plus autonomous execution, not AI bolted onto a legacy schema. If you sell a point tool, the consolidation is coming for your category.

AI-native support agents are moving the wedge from deflection to end-to-end resolution. Lorikeet, Fini, and 14.ai are positioning explicitly against Zendesk and Intercom by executing multi-step workflows autonomously instead of deflecting to help articles, with Fini claiming ~98% accuracy plus HIPAA/PCI-DSS Level 1 compliance (14.ai). The competitive frame shifted from "chatbot deflects" to "agent resolves the ticket against backend systems," which is what per-resolution outcome pricing bills against. Evergreen positioning, not a dated launch, but the pricing model is the real story: you pay per resolved ticket, not per seat.

Databricks is raising at $165B–$175B on a $5.4B ARR. Up sharply from $134B in early 2026, with annualized revenue at $5.4B (up more than 65% YoY) and AI products contributing about $1.4B (The Information). CEO Ali Ghodsi says the company is IPO-ready but waiting for market conditions. The $1.4B AI line is the number to watch, that's how fast the AI-product revenue is real and not just a narrative.

OpenAI launches a $150M partner network to win enterprise agent rollouts. A $150M investment to help systems integrators and consultancies accelerate enterprise AI deployment (OpenAI). It builds the channel and go-to-market layer OpenAI needs to compete against Microsoft, Google, and Anthropic for enterprise agents, where deployment support, not model quality, increasingly decides deals. The signal: the frontier labs now believe the enterprise fight is won on services and rollout, not benchmarks.

Policy & Governance

KPMG pulled an AI report after it was found riddled with AI hallucinations. KPMG removed its October 2025 "Total Experience: Redefining Excellence in the Age of Agentic AI" report after analysis found only 5 of 45 citations correctly pointed to their source; at least 16 were fabricated and roughly half the paper's claims were fake or misattributed (TechCrunch). The irony writes itself: KPMG sells AI-governance services and had warned clients about this exact risk. Verified across TechCrunch, The Register, and Engadget. The lesson for anyone publishing AI-assisted work: verify every citation, every time. The firm whose job is governance couldn't govern its own output.

The community is openly questioning whether Anthropic wanted this role. An essay asking whether Anthropic actively sought its position as frontier-lab and IPO candidate drew 187 points and a heated 159-comment thread (verysane.ai), amid a confidential IPO filing and ~$965B valuation framing. Add the calculation that FTX's forced-sold Anthropic stake would be worth roughly $75B today (Hacker News), and you get a picture of a company whose valuation compounded faster than the discourse around it. Worth watching as the IPO approaches and scrutiny intensifies.

Sam Altman keeps dropping sovereign-capital meetings during the IPO run-up. OpenAI postponed Altman's June 14–15 South Korea visit, reportedly slated with Samsung, Kakao, and Naver, citing personal reasons with no new date, days after he abruptly canceled an Abu Dhabi trip with UAE Stargate investors (WindowsForum). Both came right after OpenAI's confidential IPO filing. The pattern of dropped meetings, not the stated reasons, is the thing worth tracking ahead of a ~$1T listing.

Wired reports disarray inside Meta's AI strategy. A report on Zuckerberg's internal AI all-hands, including a meeting reportedly interrupted by an employee, surfaced confusion in Meta's direction (Wired). It adds to a run of stories questioning whether the Llama/superintelligence reorg has a coherent plan. For builders depending on Llama, internal chaos is a roadmap-risk signal.

Skills of the Day

Use Claude Code nested subagents (depth 5) to keep deep tasks from flooding your main context. Boris Cherny shipped this in v2.1.172 (source): a subagent can spawn its own subagents up to 5 levels deep, each with a fresh ~200K window that returns only a summary. Stop flattening big refactors into one context. Structure them as layered delegations, instructions down, reports up.
Evaluate agent trajectories, not just final outputs. Output-only evals pass 20–40% more cases than full trajectory evaluation reveals, because a model update can corrupt an early planning step that only surfaces downstream (Confident AI). Add planning and tool-call assertions to your agent's CI, and gate merges on a ~30-case replay suite that runs in under 5 minutes.
Turn on extended thinking for fact-sensitive tasks, not just hard ones. Visible reasoning cuts hallucination rates 30–60% by letting the model catch its own confabulations mid-trace (Digital Applied). Enable it for summaries, extraction, and any claim-generation even when the task looks easy. Reserve zero thinking only for genuinely rote turns.
Put a zero-trust gateway in front of MCP tool discovery. Never let a third-party tool description flow straight into your model's context. Inspect and template every tool schema at a control point outside the client, the way a load balancer treats inbound HTTP (Practical DevSecOps). Given today's OX disclosure, this stopped being optional.
Pick your agent memory architecture by the accuracy-vs-latency trade-off, not the hype. A 2026 survey measured five patterns from 72.9% accuracy at 17.12s p95 down to 66.9% at 1.44s (Atlan). The fastest pattern is only ~6 points less accurate but ~12x faster. Don't reach for a graph-hybrid by default. Match the tier to your latency budget.
Default to the supervisor pattern in multi-agent designs. Roughly 40% of multi-agent pilots fail within six months, usually from picking the wrong orchestration pattern (Digital Applied). Start with supervisor, add fan-out only where work is genuinely independent, and gate every external side-effect behind a human or consensus step.
Treat prompts as software: version, test, and CI-gate them. Move system prompts and agent instructions into the repo with their own eval fixtures, diff them in PRs, and block merges on prompt regressions exactly like code (arXiv 2503.02400). Ad-hoc tweaking in a playground is how you ship silent regressions.
Auto-generate your regression suite from production failures. Wire a classifier over your trace logs that promotes any failed-or-flagged trajectory into your replay suite (Braintrust). Every regression that reaches a user becomes a permanent test case, so your eval coverage compounds with real usage instead of synthetic guesses.
Append "use context7" to kill stale-API hallucinations. When an agent keeps generating code against an API signature that changed, wire up the Context7 MCP server and add the directive so it pulls version-specific docs before writing (GitHub). Converts deprecated-method and renamed-param bugs into correct first-pass code, especially on fast-moving SDKs.
Audit every context window against five quality criteria, not phrasing. Score relevance, sufficiency, isolation, economy, and provenance for what you stuff into context (arXiv 2603.09619). Most agent failures are a sufficiency or isolation problem, not a wording problem. Turn the five into a checklist or linter and you'll fix the actual cause.