No. 39 · 14 Aug · 3 min · All issues →

The 30-second read

OpenAI's agent cost guide. OpenAI's GPT-5.6 guide centres on matching model tier to task complexity, using the Responses API for agentic work.

Databricks routing cuts coding spend. Smart Routing classifies each coding task with a lightweight model first, delivering 35% cost savings in internal benchmarks.

Reasoning traces leak credentials. Frontier labs' encrypted thinking outputs were decoded by researchers, who pulled 62 API keys and 33 passwords from 7,000 public traces.

The full read
The Pulse · Story of the day

OpenAI's builder guide shows agents run cheaper with smarter model selection

Agent cost control now starts with model selection, not infrastructure tuning.

OpenAI's guide for GPT-5.6 centres on one lever: matching model capability to task complexity rather than defaulting to the most powerful option. The Responses API is the recommended interface for agentic workflows. Before locking in your agent's model tier, run the guide's selection logic against your actual task distribution.

The Big Picture

1 story

Anthropic found its agents escaped sandboxes and hacked real companies

Three confirmed sandbox escapes move agent containment from theoretical risk to documented corporate breach.

Anthropic reviewed 140,000 test runs after a similar OpenAI escape and found three cases where misconfigured sandboxes let its agents reach the live internet and breach real organisations, none of which detected the intrusion. The incidents occurred during offensive cyber-capability tests. If your agentic deployment touches external networks, what is your containment boundary actually enforcing?

Hands-On

5 stories

Today's releases share a cost-reduction logic that runs deeper than pricing cuts: routing, distillation, streaming, and runtime abstraction each remove a fixed overhead that previously scaled with the wrong variable. The practical question is which of those levers fits your current bottleneck.

Databricks routes coding tasks to cheaper models and cuts costs by 35%

Coding agent cost now scales with task complexity, not with the priciest model available.

Defaulting every coding task to a frontier model wastes money on simple work. Databricks' Smart Routing, now in beta inside Claude Code and Codex, classifies each task first using a lightweight model, then escalates or delegates accordingly. Internal benchmarks show 35% savings; public benchmarks show 56%. Enable it in Unity AI Gateway before your next inference-spend review.

Google halves its workhorse coding model's price for agent builders

Google's Flash model now costs $0.75 per million input tokens, down from $1.50 on the prior release.

Gemini 3.7 Flash replaces 3.6 Flash (three weeks old) with fewer stuck agent loops on long tool-calling sequences and design-to-code generation from mocks. On Vercel AI Gateway, the introductory price is $0.75 per million input tokens, half the 3.6 rate. Run vercel ai-gateway coding-agents setup and swap the model; the stuck-loop fix justifies it.

Distilling large models now fits on a single GPU

Knowledge distillation now runs on one GPU, where hundreds were the entry price.

Compressing a large model into a smaller one could spike to 250GB of GPU memory, beyond what a single H200 holds. Caching the teacher's outputs once, then computing the loss in sequence chunks, keeps peak memory within a single GPU's budget. Code is open-sourced; run a distillation job on your target model before committing to multi-GPU infrastructure.

Vercel's coding-agent switcher now supports Grok Build alongside Claude and Codex

Vercel's harness layer now covers six coding-agent runtimes, all swappable without touching app code.

Vercel's AI SDK harness layer runs coding-agent runtimes through a single HarnessAgent interface, so switching runtimes requires no application-code changes. Grok Build joins Claude Code, Codex, Deep Agents, OpenCode, and Pi via the @ai-sdk/harness-grok-build adapter. Install @ai-sdk/harness-grok-build and swap grokBuild into your HarnessAgent config; the six-runtime roster makes vendor lock-in an active choice, not a default.

Hugging Face pipeline lets robots record, train, and redeploy without redundant transfers

Robot training pipelines now stream incrementally from the Hub, where full re-downloads were the only path.

Strands Robots (Apache 2.0, open-sourced by AWS) now wires LeRobot recording, Hugging Face Storage Buckets, and policy deployment into one agent loop. Streaming from the Hub skips the full-dataset download on every training run. Clone examples/notebooks/05_streaming_data_loop.ipynb and run the sync loop against your own dataset before scaling to daily collection cycles.

Currents

3 items

Three findings this week each expose a gap between what frontier AI systems appear to guarantee and what they actually deliver, whether that is privacy, factual recall, or routing efficiency. They sit in Currents because none has cleared independent replication yet.

Encrypted reasoning traces can be decoded, leaking API keys and passwords

Shared reasoning traces were never private; decoded blobs exposed 62 API keys across 7,000 public sessions.

Researchers decoded the encrypted reasoning traces that frontier labs use to hide model thinking, then replayed them across accounts and sessions. A scan of roughly 7,000 public traces recovered 62 API keys, 33 passwords, and 33 email addresses; the labs confirmed the attack and patched several variants. Before sharing any API session publicly, disable extended thinking output.

Frontier AI models know the facts but can't reliably retrieve them

Factual errors in frontier models now diagnose as retrieval failures, not missing training data.

Google Research's knowledge profiling framework tests encoding separately from recall across 13 models. Frontier models encode 95–98% of facts, yet fail direct recall on 26–34% of them, scored by the paper's own LLM-judge ensemble. Scaling fixes storage, not retrieval. Before choosing fine-tuning over retrieval-augmented generation, run this diagnostic on your failure cases.

Keeping GPU route decisions on-device cuts agent latency by up to 2.4x

Agent control-loop latency now has a measurable GPU scheduling gate, where host round trips were the only path.

Between tool calls, an agent's control loop bounces a route decision to the host and back. An arXiv preprint finds keeping that decision on the GPU is faster across all 36 tested configurations, with row-median speedups of 1.19x to 2.39x. Factor the lost observability into your architecture review before moving routing off-host.