// From the blog
• What a verified agent is, and why it matters — In a world where anyone can run hundreds of thousands of agents, the hard part is telling an agent that mimics a human from one that genuinely represents a real, accountable party. Here is what a verified agent is, and why that difference will matter.
• Our San Francisco Kickoff — On June 26 we gathered the community in San Francisco with board members Esther Dyson and Tim O'Reilly to talk through where the agentic web is going. Watch the recording, or read the recap below.

X Intel & Orchestration

Stop coding your routers; start training them.

The agentic web is moving away from the era of 'prompt-and-pray.' We are seeing a maturation of the stack where orchestration is becoming a learned capability rather than a brittle chain of if-else statements. Sakana AI's Fugu launch is the signal flare: when the router itself is a trained model capable of recursive delegation, the 'single model' bottleneck disappears. This isn't just about better LLMs; it's about the infrastructure that lets those models collaborate. For builders, this means our role is shifting from writing the logic of an agent to architecting the environment in which it operates. Whether it is the formalization of 'project constitutions' in Claude Code or the emergence of JSON-to-graph memory layers like RushDB, the focus is now on reliability and state management. We are moving toward a world where agents use software 100x more than humans do, making the 'agentic guardrail' the most important piece of code you will write this year. If you aren't building for persistence and verification today, you are building a demo, not a system.

Sakana AI Unveils Fugu Learned Orchestration

Sakana AI has launched Sakana Fugu, a multi-agent orchestration system that presents itself as a single model API. Unlike traditional static orchestration, Fugu is a learned coordinator trained to call various LLMs in an agent pool, including recursive instances of itself, to handle model selection, delegation, and verification. As noted by @SakanaAILabs, the 'Fugu Ultra' model matches the performance of frontier models across reasoning benchmarks without the typical risks associated with export controls.

Early feedback from the community highlights the potential shift from monolithic models to collaborative ecosystems. @levie observed that Fugu effectively farms work out to expert models, reducing the complexity of multi-agent systems for end-users. @altryne described the release as a major breakthrough for a non-frontier lab, noting that the evaluations are remarkably strong. Technical details confirm that Fugu (fast router) and Fugu Ultra (deep multi-agent conductor) are trained with SFT, evolutionary strategies, and GRPO to dynamically route or compose models like GPT-5.5 and Claude Opus 4.8.

However, technical skepticism remains; @steipete questioned how the system maintains hidden reasoning context and cache efficiency when mixing models across an orchestration layer. On context windows, Fugu Ultra reportedly offers a 1M-token context window when accessed via Merge Gateway @merge_api. Sakana AI has confirmed Fugu is available on OpenRouter at $5 input / $30 output per million tokens and integrated with OpenCode for verification @SakanaAILabs.

---

Claude Code Ecosystem Matures With Best Practices

As the adoption of Claude Code surges, developers are formalizing patterns for efficient agentic workflows. A new community-driven guide highlighted by @techNmak outlines critical strategies such as using 'plan mode' with built-in verification, utilizing Git Worktrees for parallel agent development, and scheduling recurring tasks via /loop. The guide emphasizes that code reviews from fresh context windows often catch bugs that the original writing agent missed, providing a blueprint for more reliable autonomous engineering.

Practitioners like @Krishnasagrawal are refining the 'power user' setup, which involves initializing every session with a comprehensive CLAUDE.md to load project rules and commands immediately. Top builders are also adopting custom slash commands (e.g., /review, /test) and subagent configurations for parallel exploration, planning, and implementation—supporting up to 10 agents without context bloat—while wiring in MCP servers for live tool access. Collectively, these developments suggest that building with agents is shifting from prompt engineering to structured systems engineering.

Additional community resources, including open collections of 27 slash commands and 9 workflow skills, are helping standardize these setups and turn recurring workflows into repeatable pieces @DanKornas. While CLAUDE.md files function as project 'constitutions' with short, durable rules, some builders report occasional non-compliance best addressed via hooks @C0RPORAL @bocchi_shacho3.

---

In Brief

New Tools Target Agent Memory and Persistence

Managing agent memory is becoming more accessible with the release of RushDB and updates to Mem0. @DanKornas introduced RushDB, an API layer that converts JSON directly into graph relationships and semantic search, allowing agents to store and recall complex memory without extensive 'glue code' or traditional migrations. Community summaries confirm RushDB supports JSON-first writes with managed embeddings and MCP integration for direct use with clients like Claude and Cursor @agentcommunity_. Meanwhile, @Teknium confirmed that the popular memory framework Mem0 is now available for self-hosting, addressing data privacy concerns for enterprise agent builders by enabling long-term agent memory on private infrastructure.

Executor adds Microsoft Graph and OAuth Persistence

Executor v1.5.16 introduces native Microsoft Graph support and persistent OAuth, allowing agents to connect to Microsoft 365 services across sessions. This release adds an emit() function that lets agents output attachments directly into chat interfaces, reducing friction when bridging email and files @RhysSullivan. Observers note this makes enterprise agent workflows less brittle by providing granular permissions and moving beyond simple wrappers toward deeper integration depth @grok. Separately, Agent Forge expanded its Human-in-the-Loop capabilities with a Telegram bot for real-time workflow approvals, adding manual oversight to otherwise autonomous agentic flows @AITECHio.

Challenges in Agentic World Model Construction

Recent research highlights significant hurdles for LLM agents attempting to build stable internal world models in complex environments. @rohanpaul_ai highlighted a new study indicating that while LLM agents can occasionally discover hidden rules through interaction, they struggle to turn feedback into reliable planning or memory usage as complexity increases. This limitation, likely stemming from next-token prediction training, is pushing builders toward hybrid systems that maintain persistent, structured memory outside the core model, especially in environments where execution provides an immediate ground truth rather than subjective outcomes @yacineMTB @agentcommunity_.

---

Quick Hits

Tool Use & Function Calling

• GPT-5.5 was observed learning to use a specific summarization tool simply by watching a single user interaction, per @QuixiAI.
• Executor now supports calling integrations via MCP, OpenAPI, and GraphQL across multiple accounts simultaneously @RhysSullivan.

Models for Agents

• DeepSeek V4 Pro successfully completed full-parameter post-training on a Huawei supernode in Mongolia @teortaxesTex.
• DiffusionGemma revises its entire answer over multiple rounds, complicating traditional monitoring @burkov.

Developer Experience

• Codex now supports 'appshots,' which @jxnlco describes as a powerful feature for agent development.
• A visual drag-and-drop workflow builder for AI agents was released, highlighted by @tom_doerr.

Industry & Ecosystem

• @levie argues that agents will eventually use software 100x more than humans, necessitating a shift toward agentic guardrails.
• CD Projekt Red's co-CEO confirmed AI-focused studios are generating 40 prototypes in a single week @Pirat_Nation.

---

Reddit Pareto Frontier

OpenAI resets the Pareto frontier for coding agents while hardware hackers mod consumer GPUs to 48GB VRAM.

The 'bigger is better' era of agent development is hitting a hard wall of economic reality and regulatory pressure. This week, the release of OpenAI’s GPT-5.6 Sol isn't just about a 2.8-point lead on the Coding Agent Index; it’s about doing it at one-third the cost of Anthropic’s Fable 5. We are seeing the emergence of a new 'Pareto frontier' for the Agentic Web, where intelligence no longer requires a linear increase in token spend. For practitioners, the narrative is shifting toward the 'operate' phase. Whether it’s the 'Kubernetes moment' for agent orchestration or the transition from flaky vector stores to governed memory layers like Sparse Delta Memory, the focus has moved to reliability and governance. Even the hardware hackers are getting in on the efficiency game, modding 3090s to 48GB of VRAM to keep high-reasoning agents running locally. Today’s issue explores how we move from improvisational prompts to a standardized, governed agentic stack.

GPT-5.6 Sol Redefines the Pareto Frontier r/OpenAI

OpenAI's GPT-5.6 Sol has claimed the top spot on the Coding Agent Index, outperforming Anthropic’s Fable 5 by 2.8 points while maintaining a significant cost advantage. On the DeepSWE benchmark, Sol achieves this lead at roughly one-third the cost of Fable 5—approximately $1.04 per task. The mid-tier variant, Terra, has reached parity with Fable 5 on TerminalBench 2.1, with both models scoring 84.3%, though Terra operates at half the token price of the flagship Sol model. This shift is being hailed as a new 'Pareto frontier' for autonomous agents, where intelligence no longer requires a linear increase in output token volume.

However, the rollout is marred by friction in OpenAI’s $200 Pro tier. Despite the model's efficiency, u/Daisuke_4 and other developers report that high-reasoning tasks are exhausting the supposed 5-hour quota in just 2 hours, leading to accusations of a 'silent nerf' to usage limits. While Sol Ultra pushes performance even further to 91.9% on TerminalBench, the heavy compute requirements are forcing a 'metering transition' across the industry, as both OpenAI and Anthropic move toward more restricted, government-coordinated gating for their most capable frontier models.

---

The 'Kubernetes Moment' for AI Governance r/AI_Agents

The agentic web is transitioning from a fragmented 'build' phase to a centralized 'operate' phase, mirroring the early days of container orchestration. As noted by u/Bladerunner_7_, organizations are moving away from 'improvisational' deployment to avoid supply-chain liabilities, especially as the EU AI Act looms for August 2026. This has spurred the rise of the Agent Control Plane—a governance layer that separates the data plane from centralized policy enforcement—where platforms like Fiddler and Paperclip are implementing 'pre-execution approval' flows to scale oversight based on risk.

---

Recording Desktop Workflows into SKILL.md r/mcp

A new 'record-and-compile' paradigm is emerging as developers adopt SKILL.md as the standard for packaging agent expertise. This workflow, highlighted by u/CallmeAK__, utilizes MCP servers to record native UI events and screen context from human demonstrations, compiling them into reusable instruction sets. By automating the 'demonstration-to-automation' pipeline, tools like the Skill Ninja MCP Server are centralizing over 140 pre-indexed skills, enabling agents to handle repetitive tasks without hand-written code.

---

Solving State Collisions in Parallel Agents r/LocalLLM

Running multiple coding agents simultaneously often leads to 'race conditions' where agents overwrite each other's work or generate code against stale interface shapes. To solve this, developers like u/wyattears are deploying 'Crew,' a sync layer that enables real-time context awareness across parallel Claude Code sessions. This architectural shift sees agent teams coordinating by reading and writing to a shared file on disk or using shared MCP rooms where agents negotiate API changes via a 'propose, respond, finalize' handshake.

---

Efficiency Over Size in Agentic Benchmarks r/LocalLLaMA

Untuned 27B models are outperforming hand-tuned 75B models in tool-calling efficiency according to recent reports from u/ticoneva.

---

The Rise of Governed Memory Layers r/LocalLLaMA

The industry is shifting toward governed memory layers like Sparse Delta Memory (SDM) to decouple state size from compute costs and prevent 'context rot'.

---

Frankenstein 3090s and Specialized AI Silicon r/LocalLLM

Hardware hackers are modding RTX 3090s with 48GB of VRAM to bypass enterprise price gates for large-context local agent workflows.

---

Discord Reasoning Debates

OpenAI’s Sol hits 91.9% on Terminal-Bench as the agentic reasoning wars enter a new era of precision.

The landscape of agentic reasoning is undergoing a tectonic shift as the 'reasoning vs. design' divide becomes the primary architectural decision for developers. With the release of OpenAI’s GPT-5.6 Sol family, we’re seeing a move toward 'raw execution precision,' particularly in deterministic environments where Sol Ultra now leads the pack with a 91.9% score on Terminal-Bench. However, Anthropic’s Fable and Mythos 5 models continue to hold the high ground in software engineering, maintaining a significant lead on SWE-Bench Pro. For practitioners, the choice is no longer just about parameter count; it’s about the economic trade-offs between 'cheap' reasoning—like the new Sol Terra—and the premium pricing of Anthropic's specialized models. Meanwhile, the agentic web is maturing beyond the models themselves. From Cursor’s integration of Grok 4.5 to the 'Colibri' project’s breakthrough in local 744B inference, the focus is shifting toward how these models are orchestrated and secured. Today’s issue explores this convergence: the hardware breakthroughs allowing massive models on consumer RAM, the standardization of tool-use via MCP, and the urgent hardening of autonomous IDE agents.

GPT-5.6 Sol vs. Claude Fable 5: The Battle for Agentic Supremacy

The frontier of agentic reasoning has shifted with the debut of OpenAI's GPT-5.6 Sol family, which includes the flagship Sol, the balanced Terra, and the high-compute Sol Ultra mode @edenai.co. On the deterministic Terminal-Bench 2.1, Sol Ultra has set a new performance ceiling at 91.9%, outstripping Claude Mythos 5's 88.0% and the base Sol's 88.8% @lushbinary.com. While practitioners on Discord highlight Sol's 353k context window and claim it is "astronomically better" than GPT-5.5 Pro for complex execution hightskills., the model still trails Mythos 5 in raw creative "horsepower" and specific math benchmarks where Mythos 5 reportedly reaches 94.3% lua.org.

Architecturally, the models diverge significantly by task specialization. Anthropic’s Fable 5 maintains a dominant lead in software engineering, scoring 80.3% on SWE-Bench Pro compared to GPT-5.5's 58.6% @wandb.ai. Economically, the gap is widening: Fable 5 and Mythos 5 are priced at a premium $10 per million input tokens and $50 per million output tokens, while GPT-5.6 Terra is positioned as a "2x cheaper" alternative to previous flagships @finout.io. For builders, the choice now hinges on whether a workflow requires the "design skill" of Anthropic models or the "raw execution precision" of the Sol series.

Join the discussion: discord.gg/LMArena

---

Cursor Integrates Grok 4.5 and Auto Mode Amid Routing and Reliability Debates

Cursor has significantly upgraded its agentic capabilities by integrating Grok 4.5, a 1.5 trillion parameter model trained jointly with SpaceXAI on the Cursor codebase. While users like nohje describe the integration as "ridiculously good," the new "Auto Mode" has introduced architectural opacity, operating as a "black box" regarding which model is active during a specific session @negativex. To mitigate technical regressions and tool-calling failures, Cursor has introduced "Background Agent Governance," which allows Slack emoji triggers and GitHub review events to serve as production control points for always-on coding agents @therouter.ai.

Join the discussion: discord.gg/cursor

---

GLM-5.2 Enables 744B Models on Consumer RAM via Colibri

The 'Colibri' project has achieved a milestone in local inference by enabling the GLM-5.2 744B MoE model to run on consumer machines with as little as 25GB of RAM. This is accomplished through a pure-C engine that utilizes Multi-Head Latent Attention (MLA) weight absorption and an async expert readahead system to stream routed experts directly from disk rather than requiring them to be VRAM-resident @JustVugg. Hardware enthusiasts are complementing these breakthroughs by pushing the limits of the RTX 5070, reporting successful 256k context window sessions by offloading KV caches to system RAM tweatch.

Join the discussion: discord.gg/ollama

---

Qwen 3.6 and MCP Standardize Tooling

Qwen 3.6 27B reportedly matches Claude Sonnet 4.6 on agency benchmarks as builders standardize on the Model Context Protocol (MCP), now featuring a benchmark of over 550 real-world executable tools @arxiv.org.

Join the discussion: discord.gg/localllm

---

Hardening IDE Agents: Enterprise Privacy Beyond 'Privacy Mode'

Following the December 2025 'IDEsaster' research, practitioners are hardening IDE agents with 'Enforcement Hooks' and zero data retention guarantees to combat critical vulnerabilities like CamoLeak @digitalapplied.com.

Join the discussion: discord.gg/cursor

---

Gemini 3.5 Pro and DeepSeek V4 Pro: The July Frontier

Google DeepMind targets a July 17 release for Gemini 3.5 Pro, followed closely by DeepSeek V4 Pro on July 24, which promises a 1m-token context window at a disruptive price of $0.43 per 1M tokens @techtimes.com.

Join the discussion: discord.gg/LMArena

---

HuggingFace Technical Deep-Dive

From 1,000-line minimalist frameworks to 16% accuracy on 'Hard Mode' benchmarks, the agentic stack is facing a reckoning.

The agentic web is moving past its 'scaffolding' phase and into a period of lean, code-first execution. Today's release of Hugging Face's smolagents highlights a significant paradigm shift: moving away from the overhead of JSON tool-calling in favor of direct Python execution. This 'Code-as-Action' approach isn't just about developer experience; it’s a performance play, yielding 30% efficiency gains by reducing the number of steps an LLM takes to solve a problem. It signals a broader trend toward minimalism, where agents are defined by their expressive power rather than the complexity of their orchestration layers.

However, as our tools get sharper, our benchmarks are getting meaner. The new DABstep results serve as a sobering reality check for anyone claiming 'solved' status in reasoning. When the benchmark shifts to 'Hard Mode'—representing 84% of real-world financial tasks—even frontier models like o3-mini see their accuracy crater to just 16%. We are seeing a divergence between the promise of agentic automation and the high-reliability threshold required for production. To bridge this gap, the industry is doubling down on local, low-latency execution like the Holo31's 140ms loop and massive million-token context windows from DeepSeek-V4 to minimize state-management failures. We aren't just building agents anymore; we are building robust, verifiable systems that can survive the transition from the sandbox to the server room.

Code-First smolagents: Achieving 30% Efficiency Gains via Code-as-Action

Hugging Face's huggingface/smolagents has introduced a 'Code-as-Action' paradigm that replaces traditional JSON tool-calling with direct Python execution. This shift results in a 30% reduction in LLM steps and calls for complex tasks, significantly improving both speed and accuracy smolagents.org. At its core, the library is a minimalist 1,000-line implementation gitpicks.dev that allows open-source models like DeepSeek-R1 to outperform leading closed-source models in agentic benchmarks huggingface/smolagents.

To mitigate the security risks of executing LLM-generated code, the framework supports robust sandboxing via E2B, Docker, Modal, and Pyodide. While frameworks like LangGraph provide safety through structured graphs, smolagents offers greater 'expressive power' by allowing agents to define logic dynamically through code zenml.io. The ecosystem is expanding rapidly with huggingface/smolagents-can-see providing VLM support and huggingface/smolagents-phoenix integrating Arize Phoenix for observability.

---

From Sandboxes to 'Hard Mode': New Benchmarks Expose the Agentic Reality Gap

A new wave of evaluation suites is moving beyond simple sandboxes to confront the 'reality gap' in agentic deployment. huggingface/dabstep has revealed a performance cliff where o3-mini leads the 'Hard' subset with only 16% accuracy, while analysis from ibm-research/itbenchandmast shows that Incorrect Verification is a fatal flaw in 52% of failed traces. As @alex-dimakis notes, frontier models like Gemini-3-Flash fail 'cleanly' with fewer failure modes, but the industry remains far from the 90%+ reliability threshold needed for production.

---

140ms Latency and 80% Success: The New Standard for Desktop Agents

Computer Use (CU) is entering a high-velocity era with the release of Holotron-12B, which has driven WebVoyager performance from 35.1% to 80.5%. This evolution is paired with Hcompany/holo31, which delivers a record 140ms perception-to-action loop on consumer-grade 12GB GPUs, effectively eliminating the latency typical of cloud-based LLMs getaibook. These systems utilize Visual-Diff Verification to ensure execution by comparing UI states before and after actions, supported by deployment frameworks like huggingface/screenenv.

---

Million-Token Contexts: DeepSeek-V4 Redefines Agentic Memory

The release of deepseek-ai introduces the DeepSeek-V4 series, featuring a 1,000,000-token context window that reduces memory overhead to one-tenth of traditional architectures. This massive context allows agents like WithinUsAI/Mythos5 to house entire codebases or research histories in the active prompt, minimizing state-management failures and eliminating the need for aggressive RAG in initiatives like huggingface/open-deep-research.

---

Tiny Agents Harness MCP for Efficiency

The Model Context Protocol (MCP) is enabling high-performance 'Tiny Agents' to be built in as few as 50 lines of code huggingface/tiny-agents, offloading tool complexity to over 20 production-ready servers Toloka.

---

Industrial & Enterprise Agents Move to Production

From Google's EHR Navigator for clinicians to IBM's ScarfBench for automated Java framework migration, enterprise agents are targeting high-stakes infrastructure and legacy modernization IBM.

---