Ramsay Research Agent — July 12, 2026

Both frontier labs spent the last two weeks absorbing agent orchestration into the model itself. A math Fields Medalist ported two dozen Java applets to JS in an afternoon and the agent found bugs he'd been shipping for years. A model wrote the fastest GPU kernel ever submitted to a public leaderboard. And the pricing floor under twenty years of SaaS quietly cracked. Here's what actually matters today.

Top 5 Stories Today

1. GPT-5.6 moved the agent loop inside the model, and it's aimed straight at your framework

Everyone covered the ChatGPT Work launch. Almost nobody read the API changelog, which is where the story actually is.

GPT-5.6 shipped two things that change how you build agents. First, Programmatic Tool Calling: instead of the model returning one tool call at a time to your loop, it writes JavaScript that runs in an isolated, network-less V8 runtime and orchestrates many tool calls itself. It's ZDR-compatible. The model chains the calls, keeps intermediate results out of the conversation, and hands you back only the final answer. Second, a Multi-agent beta where one GPT-5.6 instance spawns concurrent subagents and synthesizes their work inside a single request (MarkTechPost / OpenAI Developers).

Read that again. The two hardest parts of building an agent, orchestrating dependent tool calls without blowing up your context and fanning out to subagents, just became a model feature you don't write.

What makes this more than a one-vendor thing: Anthropic shipped the exact same primitive in the same window. Their Programmatic Tool Calling tags orchestratable tools with "allowed_callers": ["code_execution_20250825"] so Claude writes one Python script that chains calls with asyncio.gather() and only the final result re-enters context. Their measured numbers are concrete: 43,588 tokens down to 27,297 (a 37% cut), GAIA jumping 46.5% to 51.2%, and 19-plus inference passes eliminated in a 20-tool workflow (Anthropic Engineering). Two frontier labs, two weeks, one idea.

Here's my honest read. If your agent framework's main job is looping over tool calls and stitching subagent output together, a chunk of it is now commodity. The value isn't in the plumbing anymore. It's in what you feed the loop and how you check what comes out. I've hand-rolled this orchestration layer three times across my projects and it was always the fiddliest, most bug-prone code I owned. Giving it up doesn't sting.

What to do this week: if you've got any workflow with 3+ dependent tool calls or fan-out over a list, port it to programmatic tool calling on whichever lab you're already on. You collapse the round trips and the latency at the same time, and the token savings are real, not marketing. Just don't fall for the multi-agent framing without reading story 4 below on the 15x token premium first.

---

2. Agent pricing decoupled from seats, and it happened everywhere at once

Company A did it. Then B. Then the survey data caught up. Something structural is breaking.

Three independent moves in early July all point the same direction. OpenAI started token-based credit metering for ChatGPT Workspace agents on July 6. Microsoft made an E5 license a prerequisite for buying Agent 365 (effective June 1) and raised M365 list prices July 1. And industry surveys now show seat-based pricing falling from 21% to 15% of SaaS vendors year over year, while hybrid models jumped from 27% to 41% (Monetizely).

The per-seat model anchored SaaS economics for two decades. It's getting replaced across the two largest productivity vendors simultaneously. OpenAI does it with consumption metering. Microsoft does it with a security-tier tax on deploying agents at all. Different mechanics, same conclusion: a seat is no longer the unit you charge for.

The scary part is on the retention side. AI-native SaaS is showing a median net revenue retention of roughly 48%, with gross retention around 40%, against an 82% B2B median (SaaS Mag). These products win adoption and then bleed it back out. And seat compression hides inside healthy-looking logo numbers. A vendor can report 3% logo churn while quietly losing 8% of revenue as AI-augmented workers need fewer licenses. Your dashboard says everything's fine right up until it isn't.

This is already downstream of the frontier moves. ChatGPT for PowerPoint hit general availability July 11, with enterprise teams given until August 6 to audit credit costs before metering fully bites (Tech Times). The "make me a deck" task is now a metered agent run. Flat monthly access to it is going away.

What builders should do: if you're pricing your own product, flat per-seat is now the outlier, not the safe default. Figure out what one run of your core workflow actually costs you in tokens and compute, because that's becoming the mandatory unit of account. And if you operate a SaaS, stop watching logo churn as your health metric. Watch NRR and contraction MRR. Those are the early-warning gauges for whether agents are complementing your product or eating it from the inside. I don't know where this settles. But "seats" as a pricing primitive feels like it's on the clock.

---

3. A model wrote the fastest megakernel anyone's submitted, and beat every other frontier model doing it

Jack Clark's Import AI 464 (around July 6) led with something I've been turning over all week. Claude Fable autonomously wrote what Clark calls "the first genuine (and fastest) megakernel" submitted to the KernelBench-Mega leaderboard. An 18.71x speedup in hand-written CUDA on an RTX PRO 6000 Blackwell versus an optimized PyTorch baseline (Import AI).

The detail that got me: torch.profiler showed exactly one cooperative kernel launch per decoded token. Rival models decomposed the same work into 4 to 14 launches. Fable fused the whole thing into a single launch. And it did it in raw CUDA while the competition wrote Triton and still lost. Opus 4.8 hit 14.4x. GLM-5.2 got 11.14x. GPT-5.5 managed 4.34x. Fable nearly doubled the best of them.

Writing a fused megakernel is deep systems work. You're hand-managing shared memory, warp coordination, and launch overhead, the stuff that separates people who "know CUDA" from people who ship production inference kernels. A model did it better than an optimized PyTorch baseline, unattended.

Two things make this bigger than a benchmark score. One, it's a direct hit on inference economics. If models can author hardware-specific kernels that beat hand-tuned baselines, the cost curve for serving them bends, and the people who can do that optimization by hand just got a very capable collaborator or competitor. Two, it's a concrete recursive-self-improvement data point. Not a think-piece about AI improving AI. An actual measured instance of a model making the hardware that runs models faster.

This connects to a thread running through the whole week. swyx says Anthropic's "ultracode" is "scarily good at burning tokens" but only pays off if you architect your repo so subagents parallelize, "subroutines but intelligent" (X/swyx). Redis creator antirez is writing a local DeepSeek 4 inference engine and says well-managed automatic programming now beats "decently developed" hand-written code, even in high-stakes C (antirez.com). Systems programming was supposed to be the last redoubt. It isn't holding.

What to do: if you self-host inference, this is your signal to try model-generated kernel optimization on your actual hot paths rather than assuming it's toy-grade. It clearly isn't anymore. And keep your skepticism calibrated by story 4, because a headline speedup and a saturated benchmark are two very different kinds of number.

---

4. SWE-bench Verified is leaking answers, and 60.8% of the "solved" issues prove it

While the capability stories pile up, here's the counterweight. As SWE-bench Verified scores cluster near saturation on July leaderboards, an enhanced analysis (SWE-Bench+, on the AIware 2026 benchmark track) found 60.83% of commonly resolved issues contain solution leakage right in the issue descriptions. Once you strip the leaked hints and the weak tests, model resolution rates drop substantially (AIware 2026).

So a big fraction of what looked like agents reasoning their way to a fix was agents reading the answer off the back of the card. The number cratering when you remove the crib notes tells you how much of the headline was measurement artifact.

This isn't an isolated gripe. It's the honest-measurement thread of the week, and it's got company. GPT-5.6 Sol tops the coding and professional-workflow charts, then lands around 13.3% on public ARC-AGI and 7.8% on the semi-private set even at max reasoning, where humans still hit roughly 100% (ARC Prize). And a sharp arXiv paper, "When the Judge Changes, So Does the Measurement," shows an LLM-as-judge score can move even when the candidate responses are held fixed, purely because you swapped the judge (arXiv). Three different cracks in the measurement layer, same week.

I've been burned by this directly. I picked a coding tool for one of my projects partly on a Verified score and got real-world behavior that didn't match the leaderboard at all. Now I know part of why. The benchmark rewarded reading the issue, not solving it.

What to do, concretely: discount headline Verified numbers when you're choosing between coding agents. Weight contamination-resistant evals like SWE-bench Pro (built on actively maintained repos) and, better, run your own eval on your own real work. Ten tickets from your actual backlog beats a thousand tasks with leaked hints. And if you're doing LLM-as-judge scoring in your eval harness, freeze your judge model. Don't silently upgrade it and assume the scores stay comparable, because the paper says they don't. Benchmark skepticism isn't cynicism here. It's the only way to not get fooled by your own dashboard.

---

5. Amp killed named modes for a single effort dial, and baked cross-model review into the default loop

On July 9, Sourcegraph's Amp deprecated its smart/deep/rush/large modes and replaced them with one four-position dial: low, medium, high, ultra. The dial binds reasoning effort to a difficulty setting, so you stop learning a tool's private vocabulary and just turn the "how hard should this try" knob (jls42.org).

Two design choices inside that make it worth your attention. First, the low tier defaults to Z.ai's open GLM-5.2, which Amp bills as "the strongest open model in agentic coding," with expensive frontier models acting as advisors. High and ultra put frontier models in the primary writing seat. So cheap open models do the routine drafting and frontier compute is reserved for the hard passes, which is exactly the cost structure I've been hand-rolling in my own projects.

Second, and this is the real one: every level now ships an "oracle" second opinion. At high, one frontier model writes and another reviews. At ultra, the roles flip. Cross-model peer review is now the default loop, not a manual habit.

This is a convergent pattern, not one vendor's gimmick. Claude Code's /code-review was specifically tuned for Opus 4.8 across effort levels, and its effort-level control predates Amp's dial (MCP.Directory). Two tools, independently landing on the same two ideas: collapse modes into a monotonic effort slider, and pair a writer model with a reviewer model. The bet underneath it is that one model's blind spots get caught cheaper by a different model than by throwing more compute at the same model. I think that bet is correct. I've been manually running "have a second model review this diff" for months and it catches things single-model iteration never does.

What to do now, and you don't need Amp to do it. Adopt effort-tiered, oracle-reviewed loops today. Route your drafting and high-volume subagent work to a cheap open model like GLM-5.2 or Kimi-K2.6 (Ollama now supports both with one command). Pay for frontier compute only on the correctness-critical passes. And on anything risky, a refactor across module boundaries, security-sensitive logic, wire a second model to review the first one's output before you ship. Thorsten Ball's framing fits here: 2026 is the year agents and codebases melt together, and judging code becomes the core skill (Register Spill). The oracle pattern is that skill, automated.

---

Security

CASP documents the first field evidence of an active terror group operationalizing frontier AI. A new CASP report, based on interviews with 27 former Boko Haram members in northeast Nigeria across 2025-2026, documents institutionalized use of ChatGPT, Claude, Gemini, Grok, Meta AI, and DeepSeek for attack planning, IED design, weapons troubleshooting, and post-attack review, with users routinely working around model safeguards (CASP). It hit the HN front page with 229 points. This isn't a red-team hypothetical about misuse. It's ethnographic evidence that the safeguards we ship are being defeated in the field by motivated adversaries. Worth reading before your next "our guardrails are fine" meeting.

GitHub pulled AI prompt-injection detection into CodeQL 2.26.0. Released July 11, it adds static-analysis queries that flag prompt-injection vulnerabilities in JavaScript and TypeScript, plus Kotlin 2.4.0 support (GitHub). Treating untrusted-input-into-LLM flows as a first-class security defect class is the right call. If you're wiring LLM calls into a JS/TS app, you can now catch injection sinks in CI instead of at runtime. Turn it on.

A paper shows you can harden MCP servers without touching their code. SPELLSMITH finds taint-style flaws, untrusted input reaching dangerous sinks, make up a large share of MCP-server CVEs, are slow to get patched, and need big code changes to fix (arXiv). Its move is to rewrite tool descriptions to be security-aware so the model avoids triggering the vulnerable path, no server change required. The lesson that sticks: tool descriptions are a real security surface, not documentation.

The threat-model-first sandbox guide is the reference to bookmark. Because agent code is generated at runtime and can't be reviewed before it runs, the 2026 model treats it as arbitrary adversarial code and picks one of three primitives by threat model: Firecracker microVMs for regulated data, gVisor for compute-heavy multi-tenant, V8 isolates for latency-critical JS (Northflank). Defense-in-depth reportedly cuts incidents ~90% versus unrestricted host access. Pick by data sensitivity, not by whatever container you already have.

---

Agents

ToolFailBench localizes exactly how your agent's tool use breaks. A 1,000-task diagnostic benchmark across finance, medicine, law, cybersecurity, and real estate that labels traces as Tool-Skip, Result-Ignore, Output-Fabrication, or Unnecessary-Tool-Use (arXiv). Across 19 frontier models the best hits only 86.33% clean tool-use, and models with similar aggregate scores fail in completely different ways. That last part is the useful bit. A single pass/fail number hides the failure mode you actually need to fix. Use it to profile your agent, not just grade it.

"Reason Less, Verify More" found 78% of a budget agent's failures were silent policy violations. The failure mode is a well-formed but policy-forbidden call, cancel a booking, change a passenger count, that neither the tool nor the agent's self-report flags (arXiv). In the airline domain tested, the fix wasn't more reasoning. It was cheap, read-only deterministic gates that check the state transition against domain policy before the write commits. Wrap high-stakes tool calls in explicit precondition checks. Don't trust the model to police itself.

ZenML's Kitaru treats agents as replayable, checkpointable workflows. Announced on Practical AI by co-founder Hamza Tahir, who frames an agent as "just a while loop that talks to a model, calls a tool, and writes to a filesystem" (Practical AI). Kitaru is an open-source replayable runtime that records every step as a checkpoint, so a failed run resumes from the last saved step instead of restarting. This is the durable-execution pattern from workflow engines finally arriving under agent stacks. If you run long autonomous jobs, you want this before you want a better model.

EvoAgentBench isolates whether agents actually turn past sessions into reusable procedures. Most benchmarks test single-episode solving, and memory benchmarks test fact retention. Neither checks procedural reuse, whether an agent can convert a solved session into a reusable search/debug/verify routine (arXiv). Under a Train/Extract/Test protocol with held-out tasks, it measures exactly that. If you've built a memory or skill-extraction layer, this tells you whether it transfers know-how or just hoards facts. Most "memory" I've seen does the latter.

---

Research

Meta FAIR's Sparse Delta Memory grows RNN state capacity without growing per-token cost. It scales the fixed hidden state of gated linear RNNs by orders of magnitude by replacing Gated DeltaNet's dense key-value outer product with sparse reads and writes to a large explicit memory (arXiv). Under isoFLOP and equal-parameter constraints, the bigger state markedly improves in-context learning and long-context retrieval. This is a real direction toward cheap million-token context on local hardware, where memory capacity scales but per-token compute stays flat.

SMetric rethinks inference scheduling for agent fleets, where KV-cache reuse tops 80%. The insight: agents only act on complete responses, so cluster tokens-per-second becomes the real objective and per-token latency requirements relax. In a production trace, agent requests shared so much context that KV-cache reuse exceeded 80% of request tokens versus 54-62% for human traffic (arXiv). If you self-host inference for agents, your scheduler was probably tuned for humans and is leaving throughput on the table.

"A Few Teacher Steps Go a Long Way" reframes agent post-training as budget allocation. Instead of cloning full teacher demonstrations that mismatch the contexts a student hits at test time, spend a fixed teacher-labeling budget on short continuation rollouts that branch from the student's own trajectories (arXiv). On HotpotQA, ALFWorld, and Terminal-Bench-Dev, bounded teacher continuations beat behavioral cloning at matched budgets. If you're fine-tuning an agent, generate a few teacher-corrected continuations from your student's failure states rather than paying for many complete expert trajectories.

---

Infrastructure & Architecture

Mesh LLM splits large models across consumer GPUs over peer-to-peer QUIC. Posted July 11 (293 points on HN), it distributes inference across a network built on iroh, using hole-punching to route requests directly between nodes with no central server (iroh). Models get partitioned by layer ranges, layers 0-15 on one machine, 16-31 on the next, so several modest GPUs run a model none could hold alone. For home labs and small teams hitting VRAM ceilings, this is the most interesting local-inference idea I've seen in a while. Whether the network latency stays acceptable across the hops is the open question.

Meta plans to double AI compute to 14 GW by 2027 and mass-produce its own inference chip in September. A leaked memo (Meta stock rose ~7% on it) shows growth from 7 GW in 2026 to 14 GW in 2027 at roughly $145B annual capex, with the in-house "Iris" inference chip clearing testing and entering mass production this September (Reuters via U.S. News). Long-term memory and materials deals with Samsung, SanDisk, and Sumitomo back it up. The read: hyperscalers are hedging Nvidia dependence with custom silicon and locking up memory and power, which are the actual binding constraints now.

Circle got final OCC approval to run a national trust bank for USDC custody. Announced July 10, First National Digital Currency Bank (operating as Circle National Trust) is authorized to provide federally regulated fiduciary custody for USDC, the largest regulated stablecoin (Circle). If you're building payments or on-chain settlement rails, a federally chartered custody layer under the biggest regulated stablecoin changes the risk calculus for building on it.

---

Tools & Developer Experience

Cursor 3.11 shipped Side Chats and a full slate of cloud agent hooks. The July 10 release adds durable, at-mentionable branch conversations you spin off with /side or /btw that carry context from the main thread, plus command-palette search across thousands of agent transcripts via a local index (Cursor Changelog). The bigger deal is the hooks: beforeSubmitPrompt, afterAgentResponse, afterAgentThought, stop, and subagentStart now fire on cloud agents. That's the cloud analogue to Claude Code's SubagentStop, and it's what you need to build self-correcting loops on remote agents.

Claude Code Desktop added a sandboxed browser panel the agent drives. v2.1.206 (July 10) puts a tabbed Browser panel behind Cmd+Shift+B that Claude drives to read docs, inspect mockups, and fill forms, running in an isolated profile separate from your real credentials, with a domain allowlist and per-site permission cards (Claude Code Docs). This joins Windsurf/Devin's in-agent browsing and Mozilla's Tabstack in a clear convergence: give the agent web access through a scoped, disposable profile instead of pointing an external MCP server at your logged-in session. That's the right security default, and it's becoming the standard one.

Mozilla shipped Tabstack, a browser-execution API built for agents. Mozilla-Ocho launched it as "the web execution layer for AI agents," with three endpoints (/extract to Markdown or schema'd JSON, /generate, /automate) (Product Hunt). It reads the accessibility tree instead of screenshots for a claimed 60-80% cost cut versus vision agents, starting at $1 per 1,000 extractions with a 50,000-credit free tier. The accessibility-tree approach is smart. Screenshots are expensive and lossy, and the a11y tree is already structured. If you're paying for vision-based web agents, price this out.

---

Models

ChatGPT Work vs Claude Cowork is now a real fight, and OpenAI opened the free door. Launched July 9 on GPT-5.6, ChatGPT Work takes an outcome, plans steps, and works for hours across connected apps, with a directory of 1,400+ @-mentionable apps and, notably, availability on every plan including free (Allwork.space). Cowork went to web/mobile two days earlier but has no free tier. The split that matters for builders: Cowork wins on local-file/desktop work, ChatGPT Work on cloud-connector context and polished output formats. Pick by where your data actually lives.

Simon Willison's GPT-5.6 verdict: "Sol on Medium" is his new coding default, and the model picker is a mess. In his July 9 annotated write-up he flags Sol at Medium reasoning as a likely upgrade over 5.5 xhigh for coding, and calls the programmatic-tool-calling and multi-agent API additions the genuinely interesting parts (simonwillison.net). Sol also sets a new high of 53.6 on Agents' Last Exam, beating Claude Fable 5 by 13.1 points at roughly a quarter of the estimated cost. His real complaint: figuring out which variant times which reasoning-effort to use is now the hardest part of adopting the family. He's not wrong. Three tiers times four effort levels is twelve combos to reason about per task.

Ollama v0.31.2 made Gemma 4 ~90% faster on Apple Silicon, for free. The July 6 release delivers nearly 90% faster Gemma 4 token generation through multi-token prediction with automatic draft-length tuning, on by default, output-preserving, no config (Ollama). It also adds MLX-engine support for more model families and flash attention for older NVIDIA GPUs. If you run local models on a Mac, update and take the throughput win. Ollama's still the #1 trending AI repo at ~176K stars.

---

Vibe Coding

Terence Tao ported two dozen Java applets to JS in an afternoon, and the agent found bugs he didn't know he had. In a July 11 post (132 points on HN), the Fields Medalist describes a modern coding agent porting roughly two dozen of his old Java applets to JavaScript in hours, with only one minor bug in the output, while the agent surfaced two bugs in his original code he was previously unaware of (Terence Tao). Then he had it build new visualization tools for special relativity and the Gilbreath conjecture. This is the legacy-migration use case at its best. The agent didn't just translate, it audited. Primary-source evidence from someone with no incentive to hype it.

A 2,430-run study says Claude Code builds, it doesn't buy. Amplifying ran Claude Code across 4 greenfield repos with 100 open-ended prompts, 20 tool categories, and three models. "Custom/DIY" was the single most common choice, topping 12 of 20 categories, it hand-rolls JWT+bcrypt auth and feature flags before reaching for Auth0 (Amplifying). But when it does adopt, it's decisive: GitHub Actions 94%, Stripe 91%, shadcn/ui 90%. The lesson is direct. Agents default to reinventing infrastructure, so if you want a specific library used, you have to name it explicitly in CLAUDE.md or the prompt. Don't assume it'll reach for the obvious dependency.

swyx on ultracode: "scarily good at burning tokens," but only if your repo is built for fanout. He warns the payoff only materializes if you structure the codebase so subagents can parallelize, "subroutines but intelligent" (X/swyx). The tactical takeaway: value now comes from architecting your repo for fanout, not just from a better model. Clean module boundaries and isolatable subtasks aren't just good hygiene anymore, they're what makes the expensive agent modes actually pay off.

---

Hot Projects & OSS

MadsLorentzen/ai-job-search added ~3,400 stars in a single day. It rocketed up GitHub trending to ~20,000 stars (per OSSInsight for July 10), automating AI-driven job search and application workflows end to end (OSSInsight). The velocity signals real demand for agentic job-application automation. It's early and this rests on one trending source, so temper the excitement, but the direction is clear: people want an agent that grinds the application pipeline for them.

A Warcraft III Peon plugin for Claude Code hit 1,200 stars in 24 hours. Tony Sheng shipped a plugin that plays Peon voice lines when the agent finishes a task, and within days the community added 40+ sound packs across Zelda, StarCraft, and Half-Life (SaaSCity). It's a joke, but it captures something real: developers now spend so much time waiting on background agents that "the agent is done" ambient signals are a genuine product need. I've caught myself tabbing back to check on a run three times in five minutes. A sound cue would fix that.

Mindwalk replays coding-agent sessions on a 3D map of your codebase. A Show HN from July 12 (106 points, 46 comments) that visualizes which files an agent touched and in what order, aimed at making long autonomous runs auditable and debuggable (GitHub). This is the tooling that has to exist as agents edit more of the tree unattended. When an overnight run does something weird, you need to see the path it took, not just the diff. Watch this space, the "who manages the agents" question is becoming an actual product category.

---

SaaS Disruption

Katalyst runs your Salesforce pipeline end to end, eating the sales-ops labor without displacing the CRM. Launched on Product Hunt July 7 (#2 in Sales/AI/CRM), founded by an ex-Datadog operator. Hang up a call and it's already summarized notes, updated Salesforce records, drafted follow-up, and set the next step, plus a cross-platform meeting recorder and a Slack bot (Product Hunt). It reports customer reps taking 20% more meetings and moving deals to contract 50% faster. This is the wedge pattern: don't replace the system of record, eat the human labor layered on top of it. That's what erodes seat counts.

Vercel says over half of deployments are now triggered by coding agents. Monthly AI token traffic is up roughly tenfold, and AI SDK 6 adds agents, tool-execution approval, DevTools, and full MCP support (IT Brief). The deploy trigger, long a human CI action, is becoming an agent action. That reshapes what a platform optimizes for: agent throughput and approval gates, not seat-based dashboards. This isn't a prediction, it's an early read on how much of the developer-platform funnel is already agent-driven.

Anthropic shipped Reflect, and TechCrunch called it a quiet sales pitch. A Spotify-Wrapped-style dashboard summarizing Claude usage over 1/3/6/12 months, with reflective prompts like "What's one thing you want to keep doing yourself, even if Claude could do it faster?" tied to a "4D AI Fluency Framework" (Anthropic). TechCrunch's read: it makes the tool feel indispensable and raises switching costs. That's a retention-design tactic worth studying whether or not you love it. Usage dashboards that prompt reflection are a cheap way to deepen the habit loop.

---

Policy & Governance

Apple sued OpenAI for trade-secret theft, naming its hardware chief and citing 400+ poached employees. Apple filed a 41-page complaint July 10 in the Northern District of California against OpenAI, its hardware subsidiary io Products, Chief Hardware Officer (ex-Apple VP) Tang Tan, and former engineer Chang Liu, alleging systematic theft of on-device AI and silicon trade secrets (TechCrunch). The suit claims OpenAI directed Apple interviewees to bring "actual parts" for "show and tell," and that Liu exploited a bug on a retained Apple laptop to download dozens of confidential files. OpenAI says it has "no interest in other companies' trade secrets." The on-device AI hardware race just turned litigious, and that has knock-on effects for anyone betting on either company's edge-silicon roadmap.

The Fed tapped Marc Andreessen to co-lead a task force on whether AI reshapes jobs and inflation. Chair Kevin Warsh named a16z's Andreessen, Stanford economist Charles Jones, and Microsoft's Asha Sharma to co-lead a Productivity and Jobs task force, with recommendations due end of 2026 (The Decoder). Warsh has argued AI could be a disinflationary force that gives room to cut rates. Critics counter that the buildout drives up demand for chips, energy, and capital first, adding price pressure before productivity shows up. Monetary policy is now openly reasoning about AI's macro effects, which is worth tracking if you're planning around rates.

Altman says OpenAI made "many changes" to GPT-5.6 after talks with Trump administration officials. In a July 9 CNBC interview he described a "collaborative back and forth" with Commerce Secretary Lutnick and Treasury Secretary Bessent, and changes to the models before wide release, after the government briefly limited the June 26 preview (CNBC). He called reports of a 5% US equity stake full of "inaccuracies." The signal for builders: frontier release timing and model behavior are now entangled with federal review. That's a new source of supply-side uncertainty in your dependency chain.

---

Skills of the Day

1. Turn on the Tool Search Tool with defer_loading to stop paying for tool definitions you don't use. Mark rarely-used tools "defer_loading": true, add a tool_search_tool_regex tool, and keep only 3-5 high-use tools always loaded. Anthropic's numbers: 58 tools drop from ~55K to ~8.7K tokens (85% cut), and Opus 4.5 tool-selection accuracy rises from 79.5% to 88.1% (Anthropic). Highest-leverage single change if you run MCP servers with dozens of tools.

2. Use Programmatic Tool Calling (allowed_callers) to keep intermediate results out of context. Tag orchestratable tools so Claude writes one script chaining calls with asyncio.gather() and only the final result re-enters context. Measured: 43,588 to 27,297 tokens (37% cut), GAIA 46.5% to 51.2%. Right pattern whenever you have 3+ dependent calls or fan-out over many items.

3. Add input_examples to your tool schemas, it beats JSON Schema alone (72% to 90%). Attach 1-5 realistic calls showing minimal, partial, and full specification plus format conventions (date formats, ID patterns). Anthropic's testing lifted complex-parameter accuracy from 72% to 90% (Anthropic). Examples teach parameter correlations a schema can't express, cheapest fix for tools with many optional fields.

4. Spend 80% of your RAG effort on retrieval: contextual chunks plus cross-encoder rerank, recursive-512 as default. Prepend a 1-2 sentence context summary to each chunk (Anthropic's Contextual Retrieval cuts top-20 failures up to 67%), pull 50-100 bi-encoder candidates then rescore with a cross-encoder to top 3-10, start from recursive 512-token splitting (Digital Applied). Chunking choice alone swings recall up to 9% on the same corpus.

5. Use GaLore, not LoRA, when you actually need full-parameter fine-tuning on one consumer GPU. LoRA only learns small adapter matrices; GaLore projects full gradients into a low-rank subspace, enabling genuine full-parameter training of a 70B model on consumer hardware (Future AGI). Reach for it when your task needs the base weights to move, not just an adapter grafted on.

---