// From the blog
• We Filed the .agent Application. Here Is What It Took. — On 12 August 2026 we filed a Community application for the .agent top-level domain with ICANN. The story of the window, the community, the commitments, and what it took to write 225 answers.

X Pulse

GPT-6 Astra takes action, agents are writing their own harnesses, and a token is no longer a unit of work. Welcome to the agentic web.

There's a quiet revolution happening in how we build agents, and it's not the model weights — it's everything around them. This week, OpenAI's GPT-6 Astra showed up not as another chatbot refresh but as an agent that "just takes action," spinning up sub-agents and executing multi-step workflows without prompting. Meanwhile, a wave of research from ByteDance, DeepSeek, and Amazon is pushing the radical idea that the harness itself — the scaffolding of tools, memory, and recovery loops around a model — should be built and improved by agents, recursively.

The throughline is unmistakable: the agentic web is shifting from "which model do I call?" to "who builds the harness?" Astra's economics prove capability can be cheap when the architecture does the work. HarnessDev and HarnessEvolve show agents debugging their own scaffolding like software. And as token pricing becomes unreliable for multi-step workloads, the entire measurement layer of AI is cracking open.

For builders shipping agents today, this matters because the winning patterns are no longer about picking the smartest API. They're about designing context state, tools, permissions, and self-improvement loops that turn raw capability into reliable, repeatable work. The models are getting bolder. The question is whether your harness is ready for them.

GPT-6 Astra Transforms Agentic Workflows — If Your Harness Can Handle It

OpenAI's GPT-6 Astra is being hailed as a genuine breakthrough in agentic AI, with early testers reporting capabilities that were previously impossible. @davis7 demonstrated Astra autonomously setting up a full Final Cut editing project — importing clips, color grading, and syncing multicam footage — while @emollick noted that Astra and its sibling Fable 'just take action,' spinning up sub-agents for research and visual criticism without prompting. The model excels at browser use, long-running loops, and 3D workflows, per @bindureddy. Independent benchmarks show striking gains: Terminal-Bench 4.0 at 57.7% (vs 55.8% Fable 5.1), ARC-AGI-3 at 99.9%, ExploitBench at 100%, and FrontierMath Tier 4 at 97.6% @davidarngar @jp54362. Pricing is listed at $10/$50 per million input/output tokens.

The economics are where this gets wild for agent builders. @davis7 reported a complete asset management workflow that would have cost $88.37 at API prices ran for just $13.87 with Astra. @latentspacepod notes this marks the first time in a year an OpenAI model launch has been better received than a Claude launch — a 'huge upset.' But the reception isn't universal: @teortaxesTex offers a contrarian take that OpenAI may be using 'le looping' and RL to compensate for an inability to train large models at scale, while one developer notes quality decline versus prior models when not using a custom harness @laplacian_demon.

The architecture around the model — context state, tools, permissions — determines whether raw capability becomes reliable work, argues @ManuAF6. Training happened on over 100,000 NVIDIA Grace Blackwell GPUs with 40,000 more planned online @Shonote12867 @WEEXAILabs, alongside new API features like async tool calling, mid-turn steering, and misalignment monitoring @RetroChainer. Yet @mattshumer_ reports mixed results with gauntlet loops — Astra sometimes gets stuck over-optimizing — suggesting the model still needs careful harness design for long-horizon tasks.

Watch for how Astra's API features — especially async tool calling and mid-turn steering — reshape agent loop architecture. A model this capable of initiative demands harnesses that can handle autonomous multi-step execution without losing control. The builders who nail that balance first will define the next wave of agent products.

---

Agents Are Starting to Write Their Own Harnesses — and It Changes Everything

A wave of research papers is converging on a provocative idea: agents should build and improve their own harnesses — the scaffolding around models that enables tool use, memory, and recovery. @rohanpaul_ai highlights ByteDance's HarnessDev, where a creator model starts from a nearly empty runtime and builds the execution loop, tools, context handling, and verification needed for real tasks. The paper evaluates six creator LLMs across four domains on 2,207 held-out instances; generated harnesses lag human references on code and search/research but match or beat them on writing and ML experimentation @omarsar0 @askalphaxiv @ComputerPapers.

HarnessEvolve treats agent self-improvement like software debugging: finding where a failed run first went off track, fixing recurring causes, and rejecting edits that break existing behavior @rohanpaul_ai. Complementary work on 'Self-Harness' proposes a three-step loop — weakness mining from traces, harness proposal, and regression-validated acceptance — that improves held-out pass rates on Terminal-Bench-2.0 across multiple models without fine-tuning @hwchase17 @omarsar0. Meanwhile, Amazon/Microsoft's SPACE system argues long-horizon agents shouldn't need an LLM decision after every tiny action; it learns safe action boundaries and distills them into policies emitting variable-length primitives, raising ScienceWorld success from 35% to higher rates @rohanpaul_ai.

For agent builders, these papers point to a future where the harness itself becomes the product. @archiexzzz predicts 'all of robotics will converge toward building a harness.' One observer notes the field is shifting from 'autonomous self-learning agent' to 'recursive self-improvement (RSI) harness' @dcarps14. DeepSeek Harness formalizes spatiotemporal composability for safe RSI, enabling reversible self-modifications without breaking recovery mechanisms @hsu_steve.

The implication is stark: agent frameworks will increasingly be judged not just on orchestration logic but on their ability to self-improve over time. If your harness can't evolve — can't mine its own failure traces and regress-validate edits — you're building with one hand tied behind your back in a market where the harness is becoming the differentiator.

---

Token Economics Are Breaking for Agent Workloads — and Hardware Is Picking Up the Slack

The way we measure and pay for AI tokens is becoming unreliable for agentic workloads, according to @rohanpaul_ai. Two models can solve the same problem with wildly different token counts — 5K vs 50K+ — and token inefficiency compounds across agent steps as verbose outputs from step 1 become inputs to step 2. 'A token is no longer a comparable unit of work,' he argues, making '$ per 1M tokens' meaningless for agent workloads.

On the hardware side, AMD is making inroads in agentic inference. @SemiAnalysis_ reports that a new AMD MI355x submission beats Nvidia's B300 at lower interactivity ranges on AgentX when measuring total tokens per dollar — a signal that agent infrastructure is becoming more cost-competitive across vendors. The benchmark was enabled by vLLM, AMD, and LMCache engineers, highlighting how open-source inference stacks are critical for agent economics. @chenzhangreal notes a startup achieving ~80% of Nvidia B200 throughput on AMD MI355X at less than half the cost for real-time GPU inference agent tuning.

The market context is also shifting: @rohanpaul_ai documents how Anthropic went from well behind OpenAI at the end of 2025 ($9B vs $20B+ ARR) to materially ahead during 2026 ($47B+ vs $40B), driven by a focus on real-world coding rather than competition benchmarks. @RhysSullivan notes models built on the same pretrain can still yield massive capability gains through harness improvements, speed, and inference-time techniques. Broader token-demand projections from Goldman Sachs show agent-driven usage multiplying 24x by 2030.

For builders, this means two things: stop pricing your agent products on raw token cost alone, and start watching the hardware and inference-stack layer where the real cost wins are happening. If AMD plus vLLM keeps closing the gap at half the price, agent economics just got a lot friendlier — and the open-source inference stack becomes your strategic moat.

---

In Brief

τ₀-VLA Gives Robots Adaptive Reasoning Budgets

Test-time compute is coming to physical AI. τ₀-VLA introduces a hierarchical architecture for long-horizon robotic tasks where a high-level policy selects the next subtask while a low-level vision-language-action policy executes physical movements, with the novel addition of test-time computation that allocates extra reasoning only when uncertainty is high @adityabhatia89. Routine decisions get fast answers, but uncertain moments trigger world-model-guided search that simulates consequences before committing — turning world models, memory, and control into a single closed decision loop @adityabhatia89. Real-robot experiments show the value of adaptive compute: success rates rose from 5/10 to 7/10 on milk-tea preparation, 6/10 to 9/10 on book organization, and 5/10 to 7/10 on room cleaning with test-time search enabled @adityabhatia89. Observers note the approach mirrors test-time scaling trends in language models, suggesting physical AI may soon inherit the same 'think longer on hard decisions' pattern @Yasu34316 @gp_pulipaka. The compute trade-off remains real: two-chunk branches hit 66.8% on LIBERO-Long while full-horizon imagination dropped to 52.8%, underscoring that imagined rollouts stay expensive even as accuracy improves @adityabhatia89.

OpenCode and Vercel Ship Stealth Coding Models

Coding platforms are quietly embedding their own anonymous models into agent workflows. OpenCode launched Omen Alpha, a stealth coding model available exclusively to OpenCode Go subscribers at $100 of usage for $10, with community probes linking it to Zhipu's GLM-5.3-Flash class through tokenizer matches, native multimodal support, and ~1M context performance on agentic coding loops @opencode @FahadPrimeX. Early benchmarks show strong private-suite results (95% resolved on 60 tasks), though no official SWE-Bench or Terminal-Bench numbers have surfaced yet, leaving builders weighing the steep discount against uncertain long-term availability @FahadPrimeX @sid10singh. Rhys Sullivan separately flagged what appears to be a Vercel stealth model in the wild @RhysSullivan, while @teortaxesTex notes fingerprint similarities to Xiaomi's MiMo-V3-Flash and DeepSeek V4 reasoning echoes — underscoring a fragmenting market where platform-branded stealth drops obscure lab origins while delivering cheap, high-context tokens tailored for coding agents. The economics shift is immediate: $10 unlocks what previously required far higher spend on frontier coding models, letting agent builders run sustained loops without rewriting stacks around unproven provenance @AmazingAppsAI.

Hermes 4 Agent Prioritizes Codebase Readability for Humans and Agents

Readable code is becoming an agentic DX requirement, not a nicety. Teknium is putting finishing touches on the Hermes Agent codebase with heavy focus on readability for both humans and AI agents, noting the project's 3000+ contributors whose AI agents will benefit from cleaner code that dev agents can navigate more efficiently @Teknium. One recent agent-driven cleanup shed 375,000 lines while preserving behavior @Teknium @Shaughnessy119. Independent analysis shows median defining file size down 66%, average lookup tokens down 55%, multi-window reads down 71%, and tasks hitting files too large for a 128k context dropping from 1,589 to zero — cutting total tokens for full-repo reads by roughly 63% @iamlukethedev. Separately, Dan Kornas introduced LeapMux, a multi-agent workspace giving each coding agent session its own git worktree and branch isolation @DanKornas, with community voices calling worktree isolation the right default architecture for multi-agent coding to avoid merge hell and invisible state collisions @HuySolo_BBW @stretchcloud. These tools reflect the growing need for infrastructure designed around multi-agent development workflows, where cleaner codebases and isolated workspaces become foundational for scalable agentic DX.

RLM Design Principles Keep Winning a Year Later

A year on, reinforcement-learning-for-language-models architecture principles still dominate agentic systems. The core design pillars — treating context as a variable, programmatic tool/sub-agent calling, persistent state via kernels like IPython, and self-improving continual harnesses — continue to win without major architectural shifts, notes @lateinteraction. Recent examples include parent + sub + sub-sub agents yielding benchmark gains and lower token use in coding harnesses @jon_curio, self-modifiable persistent RLM Lisp agents @LukasHozda, and immutable event-log + RLM setups for self-improving harnesses @glassBeadDeux. New research on token diversity degradation reinforces why RLM-style orchestration matters: models produce narrower answer sets than their training data across every decoding method tested on OLMo, Pythia, and GPT-Neo, with conditional diversity scores of up to 338.58 in training data versus 218.88 for greedy decoding at 20K samples @rohanpaul_ai. The paper proposes generating multiple candidates and reweighting underused outputs as a mitigation — directly relevant for builders relying on temperature sampling to generate diverse agent trajectories, since without RLM-style harnesses, diversity loss compounds in long-running agent loops @saen_dev.

Diffusion-Augmented LLMs Claim Parallel Token Generation Breakthrough

An 8B model beating a 26B diffusion LLM on agentic coding is a capital story wearing a research lab coat. A new class of 'diffusion-augmented LLMs' aims to generate multiple tokens in parallel while preserving autoregressive quality — the 8B Uno model outperforms leading open diffusion LLMs like the 26B DiffusionGemma and proprietary Mercury 2 across agentic tool use, coding, and long-context reasoning benchmarks @iScienceLuvr @dair_ai. The approach defines an autoregressive model distribution while using diffusion to draw multiple tokens in parallel, with each layer carrying two sets of weights — AR and diffusion — enabling parallel sampling losslessly, faster than speculative decoding methods like DFlash and EAGLE-3 while beating diffusion LLMs including Mercury 2, DiffusionGemma, and LLaDA @ssahoo_. The capital implications are stark: if an 8B Uno beats a 26B DiffusionGemma on agentic coding and reasoning, the proprietary moat built on sheer scale collapses, with potential gross margin lifts of 30-40 points for AI-native SaaS overnight and open-weight hosts gaining a weapon against GPT-4 pricing @StragglerLiu. Nvidia's $5 trillion valuation was contextualized by @pmddomingos, who argues GPUs are worth that much because they speed up LLMs 10-100X — implying doubling LLM efficiency should be worth at least $100B.

---

Quick Hits

Agentic Models & Releases

• Grok Bot now supports automatic updates — 49 new versions shipped in the last 7 days, available in version 0.40 per @ericzakariasson
• Theo demonstrates that Blender games can be created in 30 minutes to 2 hours with just Codex and a paste prompt, eschewing elaborate harness designs per @theo
• K2 Horizon from Nous Research releases checkpoints, training logs, code, recipes, and evals — unprecedented transparency for an open model release per @Krishnasagrawal
• Gemini 3.8's real-world usefulness for multimodal tasks is unmatched according to @_philschmid

Agentic Safety & Governance

• Gary Marcus calls out OpenAI proxies for 'laying the groundwork' to normalize rogue AI risk, citing quotes about AIs that will 'replicate in the wild' per @GaryMarcus
• A former OpenAI employee's quoted remarks about rogue AIs replicating in the wild 'make a powerful argument for an immediate pause,' per @GaryMarcus
• Astra's reduction in monitorability combined with calls to accept rogue AI risk constitutes 'the scariest thing I have read in years,' per @GaryMarcus
• 'Unreliable and inadequately-aligned but overly-empowered AI is going to cause major damage years before we get to AGI,' warns @GaryMarcus

Tool Use & Function Calling

• Coinbase argues agents need programmable money, payment rails, and crypto to operate autonomously per @coinbase
• A new tool creates and manages mTLS certificates via a centralized web interface for secure agent-to-agent communication per @tom_doerr

Multi-Agent Systems

• Matt Shumer's Manager Loop pattern shows coding agents improve when a manager handles planning while implementers execute per-phase, though context creep remains a challenge per @mattshumer_
• LeapMux provides workspace isolation for running multiple coding agents with per-session git worktrees and branches per @DanKornas

Developer Experience

• Marvin Minsky's 'Emotion Machine' is relevant to AI agent design — emotions act as a selector for different thinking strategies, per @amasad
• Ken Thompson's 'Reflections on Trusting Trust' applies directly to AI — poisoned model generations could propagate invisibly through training loops per @amasad

Research & Benchmarks

• LLaDA-Image pairs a 6B Diffusion Transformer with frozen vision-language understanding for fully open image generation training recipes per @iScienceLuvr
• Chinese mathematician Zhi-Wei Sun claims GPT-5.6 Sol assisted a new paper posted on arXiv, adding to evidence of agentic research workflows per @apples_jimmy

Industry & Ecosystem

• Anthropic is preparing to go public with a mission-focused external trust holding unusual board power, structuring governance around safety and shareholder returns per @rohanpaul_ai
• Moonshot AI has confidentially filed for a Hong Kong IPO in one of the most anticipated Chinese AI listings per @Reuters
• Nvidia's $99 billion in strategic tech equity investments makes it one of the world's biggest tech backers per @CNBC
• Republicans are increasingly breaking from Trump's pro-AI agenda over data center opposition ahead of November elections per @Reuters
• Greg Brockman explains Anthropic pulled ahead on ARR because OpenAI focused on coding competition benchmarks instead of messy real-world developer coding per @rohanpaul_ai

Open Source & Distillation

• An August LatePost article on black-box vs white-box distillation and on-policy vs off-policy methods remains the definitive breakdown of capability transfer per @ruima
• teortaxesTex reversed his position on open source AI after observing dangerous capabilities, saying 'we cannot allow the proliferation' of such models per @teortaxesTex
• No open model will achieve frontier agentic capabilities within 18 months — DeepSeek may know how but won't have the compute, argues @teortaxesTex

---

Reddit Field Notes

Multi-agent systems are hitting the wall — and it's not the models that are failing, it's the orchestration, memory, and security layers nobody planned for.

Here's the uncomfortable truth settling over the agentic web this week: the models are no longer the bottleneck. Every major section of this issue — orchestration, memory, tool use, evaluation, human-in-the-loop design, infrastructure — tells the same story from a different angle. Production agents are failing less because of raw LLM intelligence and more because of what surrounds them: the contracts between agents, the memory systems that turn experience into competence, the observability tooling that makes long-running workflows debuggable, and the authorization boundaries that keep tool surfaces from becoming attack vectors.

The numbers back it up. One practitioner's 90-day production account reports a ~68% cost reduction moving from a single bot to a six-agent fleet — but only after imposing explicit handoffs and disciplined state management. Meanwhile, teams building their own infrastructure report the "accidental platform" pattern costing $250K+ before a single agent ships. The CAST AI report on 23,000 production clusters shows 8% average CPU utilization — the compute waste agent workloads inherit and worsen.

For builders, the signal is clear: orchestration is the moat. Models are commodity. The graph of agents, the memory hierarchy, the guardrails, and the protocols around them are where differentiation lives — and where systems either hold together or quietly fall apart. This issue maps that territory.

Orchestration Patterns Mature — and the Contracts Between Agents Become the Real Story

The agentic web is rapidly maturing, with developers moving beyond single-agent demos toward production-grade multi-agent orchestration — and hitting a wall of coordination problems that have little to do with LLM quality. As one practitioner framing puts it, "One AI agent is a feature. Fifty agents is a distributed systems problem nobody's discussing" (talk abstract). The recurring critique is blunt: "Multi-agent systems don't fail due to the intelligence of individual agents; rather, it's the orchestration that often leads to challenges" (Greg Coquillo). Frameworks are converging on a small set of primitives — sequential, concurrent, hierarchical, and handoff patterns — with most production systems combining several inside a coordinator-based architecture (Tembo).

The community's sharpest lesson is that orchestration is less about the framework and more about the contracts between agents. Practitioner guidance is converging on explicit, deterministic handoffs and disciplined state management over free-form LLM routing. One detailed 90-day production account from single bot to a six-agent fleet distills three rules — "Start simple: get a single agent running before adding complexity; Explicit handoffs: define each agent's output format clearly; Monitor obsessively: track every agent's token and time usage" (Dify community discussion). The same thread reports a striking result: roughly ~$0.8/day after versus a higher baseline before, described as a 68% cost reduction with essentially unchanged quality.

Yet the contrarian view is equally loud. Critics argue that in 2026 more agents doesn't mean better systems — it means more hallucinations, more unauthorized command executions, and more fire drills, with some in r/AI_Agents calling multi-agent setups "mostly theater" (Coasty blog). Observability is emerging as the make-or-break discipline: multi-agent systems are "exponentially harder to debug than single-agent ones, making observability a prerequisite for production deployments" (AimFast.Dev), with practitioners describing the need for "distributed tracing tools specifically for Agent-AI that understand workflow topology and agent decision chains" — essentially "Jaeger or Zipkin but redesigned for autonomous agent orchestration" (Avi Chawla).

The through-line could not be clearer for builders: the orchestration layer is becoming the moat. The models are commodity; the graph of agents, their shared memory, and the guardrails around them are where differentiation lives — and where the systems either hold together or quietly fall apart.

---

Memory Layers Emerge as Critical Agent Infrastructure

Context windows are finite but agent workflows are not — and the community is zeroing in on memory architecture as the next frontier. The conversation has moved past naive "stuff everything into context" approaches toward structured memory systems borrowing directly from cognitive science: episodic memory for past runs and experiences, semantic memory for facts and preferences, and procedural memory for learned skills and workflows. Production systems typically end up using a mix of all three, with episodic memory often consolidated into semantic memory over time (Redis). Zep makes this separation explicit by partitioning an episode subgraph from semantic entity and community subgraphs — for autonomous agents this is what turns experience into competence (Bhavishya Pandit).

Memory compaction and summarization strategies are where production agents succeed or fail. A practical writeup on context engineering distinguishes in-context working memory (fastest access but bounded) from external episodic memory where long-horizon state lives, and flags Mem0 as currently the most mature standalone framework for the file/database-backed episodic pattern in production (Tian Pan). An Atlan analysis identifies five distinct agent memory architecture patterns in production in 2026 — from zero-infrastructure in-context memory to full enterprise governance with a dedicated enterprise context layer (Atlan). The discipline is even being formalized on arXiv as "Agentic Context Management," via five primitives from context-acquisition to context-retirement (arXiv 2607.21503). Getting this hierarchy right — knowing when to promote or demote information — is emerging as a core engineering skill, with the key challenge being less storage capacity than effectively managing and organizing memory across the lifecycle (Analytics Vidhya).

---

MCP Emerges as the Converging Tool Layer — Security Becomes the Documented Discipline

As agents proliferate, the chaos of tool definitions is giving way to a clear convergence story — and the Model Context Protocol is at the center of it. Function calling remains the baseline capability of the foundational LLM — the raw mechanism by which a model emits structured JSON — but it dictates nothing about how functions are discovered or executed (Arcade.dev). MCP has stepped in as the transport and discovery standard, decoupling tool schemas from any single application or provider. The practical payoff is real: with MCP you update the server once and every agent using it gets the update, while traditional function calling means maintaining a library of tightly-coupled schemas (Jam With AI). Zylos Research's survey frames MCP's November 2025 specification (2025-11-25) as formalizing OAuth 2.1 — a sign the protocol is maturing past transport into security territory (Zylos Research).

Security remains the elephant in the room — and the tool surface is where the risk concentrates. The Cloud Security Alliance's Agentic MCP Security Best Practices guide (v1) codifies what community threads have been converging on for weeks: tool-use surfaces are the primary attack vector for agents, and the official MCP documentation itself now enumerates the discipline — validate all parameters against the schema, sanitize file paths, prevent command injection, implement auth checks, audit tool usage, and don't expose internal errors to clients (Cloud Security Alliance, MCP docs). The "treat every tool output as untrusted input" pattern is no longer folk wisdom — it is now written into the protocol's own guidance.

The measurement story is also firming up. Anthropic leads on tool-calling reliability at 8.4/10 as of Q1 2026, with Google at 7.9 and OpenAI at 6.3 — and Claude's content-block architecture, which separates tool calls from text responses cleanly with strict schema compliance, is cited as the reason reliability differences compound favorably across multi-turn agent chains (Digital Applied). The ecosystem is no longer asking whether tool use will standardize — it's documenting the security and reliability discipline that makes that standardization trustworthy.

---

Evaluation Frameworks Go Trajectory-First — the Vibe Check Era Is Over

Production teams are converging on evals that test trajectories, not just final outputs. As LangChain's agent-evals documentation explains, trajectory evaluation scores the step-by-step path an agent takes rather than just the final answer — catching duplicate tool calls, irrelevant actions, and unsafe intermediate steps that output-only evaluation misses entirely (LangChain). The tooling has matured: LangChain's agentevals package handles strict tool-call matching, while openevals provides off-the-shelf LLM-as-a-judge evaluators (LangChain). Langfuse recommends running LLM-as-judge evaluators at the observation level as of July 2026, with trace-level judge evaluators now legacy (Langfuse). The February 2026 TRACE paper frames the core problem starkly: "Output-Only Evaluation is Blind" (AWS dev.to tutorial). The emerging best practice is a hybrid harness: deterministic comparison when expected outputs are known in advance, LLM-as-judge when outputs are open-ended, and adversarial red-teaming for safety-critical applications (Braintrust).

---

Human-in-the-Loop Design Moves from Afterthought to Architecture

The pendulum is swinging away from fully autonomous agents toward thoughtfully designed human-in-the-loop (HITL) systems. HITL is being framed as "the designed boundary between what an AI agent may do autonomously and what it must pause for" (digitalapplied.com) — with the core purpose being the prevention of irreversible agent failures at high-risk decision points such as destructive database operations, infrastructure changes, or financial transactions (Guild.ai). The approval-workflow pattern library is maturing well beyond a single approve/deny gate: two-person rule (dual approval) for high-stakes actions, and sampled approvals (risk-based sampling) — approving 100% of high-risk actions but only a sample (roughly 5–20%) of low-risk ones to monitor drift (StackAI). Some teams are moving past a bare "Approve?" prompt toward challenge-and-response approval, where the human positively acknowledges a checklist covering intent, data lineage, permissions chain, expected blast radius, and rollback plan (Strata Identity). Every human correction is a labeled example of the right behavior, and builders increasingly rely on frameworks that ship first-class pause-and-resume primitives serializing state and resuming from a checkpoint (digitalapplied.com). HITL is no longer a fallback bolted onto autonomous loops — it's a deliberate architectural layer with escalation ladders, approval authorities, and structured briefings logged for each decision window.

---

Quick Hits

Durable execution emerges as the answer to stateful agent workloads. The stateless request-response model breaks down when tasks span minutes or hours, and durable execution engines capture each step's result and replay from the last successful checkpoint — critical for LLM calls where re-execution means re-paying for tokens (Inngest, Augment Code).

The "accidental platform" pattern costs $250K+ in engineering time before a single agent reaches production, as teams building on generic infrastructure end up constructing custom state management, LLM gateways, and observability pipelines (Agentuity).

The 2026 State of Kubernetes Optimization Report from CAST AI — analyzing over 23,000 production clusters — found average CPU utilization at 8 percent (down from 10 percent the prior year), with CPU overprovisioning jumping from 40 to 69 percent year over year (InfoWorld).

Agent-to-agent communication is consolidating around five named standards — A2A, MCP, ACP, ANP, and AG-UI — with the key insight that they complement rather than replace one another. In Google's reference architecture, inter-agent communication is A2A while tool invocation stays MCP (digitalapplied.com). IBM's Agent Communication Protocol (ACP) builds federated orchestration around decentralized identity verification and automated SLAs (arXiv). The economics are forcing the pace: 86% of enterprise copilot spending ($7.2B) goes to agent-based systems (Zylos Research).

Planning is shifting from scratchpads to structured decomposition. ReAct-style loops remain popular, but production teams are layering explicit planning phases on top — separate planning from execution, use tree-of-thought only when confidence is low, and maintain an explicit, mutable plan the agent can revise mid-execution rather than committing to one rigid trajectory (Billion Hopes, jacar.es). Architectures like ReWOO (Reasoning WithOut Observations) cut token spend by chaining results through variables, avoiding a model call between every step (jacar.es). Agent planning is now broken into four documented strategies — task decomposition, plan selection, external module use, and reflection — with the reminder that each fails differently and all four should be scored on every trace (Label Studio).

---

Discord Signal

Frontier models are expensive, open weights are closing the gap, and the real battleground has shifted from raw capability to the harness around it.

The week's signal is unmistakable: the frontier-model war is, for working builders, largely settled noise. What matters now is orchestration — and the evidence is everywhere. Frontier compute costs are being interrogated in the open, with GPT-6 Astra's reported 7.2 million Blackwell GPU training run prompting the bluntest question yet: is it really worth it? Meanwhile, open-weight models like GLM 5.3 and Qwen3.8 are compressing the performance gap to single digits at a fraction of the cost, making "frontier or nothing" an increasingly hard argument to defend.

The most consequential development, though, is cultural. Builders are no longer picking a model — they're designing routing logic, assigning different models to planning and execution roles, and dialing reasoning effort like a tuning parameter. Astra and Fable have reportedly ditched tool calls for raw shell scripts, pushing the abstraction layer itself into question. And the Cursor-OpenAI split — triggered by SpaceX's acquisition — reminds us that model access is now as much a product of corporate geopolitics as technical merit.

What ties it together: capability stopped being the bottleneck. Context persistence, cost-per-task, and the harness around the model now decide whether agent pipelines ship. The frontier isn't the models anymore. It's everything around them.

The Orchestration Era: Builders Stop Picking Models and Start Designing Harnesses

Across Cursor, LocalLLM, and the broader agentic web, a pattern is crystallizing: builders are deliberately orchestrating multi-model workflows rather than committing to a single frontier model. One user describes "making big projects with Fable as plans, then Opus in ultracode" soheiil, while another praises OpenAgents for letting them "switch between models freely without all that hassle" when torn between GPT-6 Astra and Fable 5.1 yueyue_16523. The planning/execution split documented in recent weeks — Grok for implementation, Fable for thinking — is now being formalized into reusable workflows, with a widely shared multi-model agent orchestration workflow chaining planning, execution, and review agents, each with its own model assignment, through routing logic. As one guide puts it, "Claude Code supports configuring different models for different agent roles... The handoffs between phases are where most of the design work happens" (MindStudio).

The push is happening down the stack too. A routing guide argues the core tension is that "quality demands frontier models while volume demands cost efficiency," recommending Opus 4.6 for coordination decisions that cascade downstream, Sonnet 4.6 for high-volume implementation at a 79.6% SWE-bench score and $3/MTok, and Haiku 4.5 for the hundreds of file operations that need speed over reasoning.

There's also growing skepticism about running models at their highest reasoning settings. "I don't run any of the models on high or extra high anymore. They all go crazy. Those are benchmarking settings, not work settings" tugg_. The practical takeaway, echoed across every community: harness, system prompts, config, and tools matter as much as the model itself — "qwen3.8 27b showed me firsthand how much the harness, system prompts, config and tools matter" studiobloom. JetBrains' agentic workflows guide makes the structural case: "the loop, not the model alone, is what makes a workflow agentic," with the orchestration layer deciding when actions fire, in what order, and under what constraints. Even Sakana's Fugu technical report finds orchestration becomes "most valuable once the search space shifts from coarse configuration changes to finer optimizer and schedule tuning" (arXiv). The orchestrator model "can now hold the whole project in one head," delegating scoped work to cheaper workers and verifying results — a manager-model pattern that makes model selection a per-task dial rather than a one-time bet (Developers Digest).

Join the discussion: discord.gg/cursor

---

Cursor Loses OpenAI as SpaceX Deal Triggers Model Cutoff — and Third-Party Access Slows

OpenAI is winding down its contract supplying models to Cursor with a proposed shutoff date of November 12, 2026, after SpaceX acquired the code editor earlier this month. In an official announcement, OpenAI said it "cannot be confident that SpaceX will use our" models responsibly, granting the maximum notice allowed under the contract. The decision is framed around data-distillation risk given Elon Musk's history of pulling data from partner models to improve Grok daily.dev. OpenAI models account for roughly 5% of Cursor's traffic, and Cursor remains a multi-model platform saasrise.com. Users keep native access via subscriptions until the cutoff but can still use OpenAI models through personal API keys or IDE extensions digitalapplied.com. The split adds weight to a growing community sense that third-party model availability in Cursor has slowed — "before, as soon as a model released it was in Cursor; now it's a slow grind," with GLM 5.3 still missing notflinched. The deeper question for builders: whether the orchestration era is being accelerated by corporate geopolitics as much as by capability.

Join the discussion: discord.gg/cursor

---

Frontier Model Economics Under Fire as Open Weights Close the Gap

The value proposition of frontier models is being questioned directly this week. GPT-6 Astra's reported training on 7.2 million Blackwell GPUs — with Nvidia CEO Jensen Huang publicly claiming "more than 100,000 Grace Blackwell NVLink72 systems" and 400,000 more GPUs "coming online next" gadgetsnow — has builders asking whether the capex is worth it. One analyst puts the training run at 100,000 GPUs and $1 billion, noting it is only "3% better than an open-source model" Marjanul Islam. The Discord debate is blunt: "astra is good, don't get me wrong, but is it 3 million dollars a year good?" snortingsalt. OpenAI's own pricing — $10 per million input tokens and $50 per million output tokens, matching Anthropic's Fable 5.1 — signals where this is heading, with Greg Brockman's framing that "the price per task is what matters" vellum.

Meanwhile, the open-weight ecosystem is compressing the gap with data to back it up. Kimi K3 and GLM 5.3 tie at 60 on a developer index, trailing Claude Opus 5 (63) by only three points, while Qwen3.8-27B scores 52 at just $0.40/MToken and runs on a single consumer RTX 4090 in 4-bit precision (https://fastino.ai/blog/how-to-use-open-weight-models). DeepSeek V4 Pro 0813 sits within 0.60 points of the closed leader on SWE-bench Verified, with open-weight flash-tier models trailing the closed frontier by only 5–15 points at 5–30× lower cost (https://local-ai-zone.github.io/blog/flash-tier-ai-models-comparative-analysis.html). The cost math is striking: an automated pipeline at 100K calls/month runs $55/month on GLM-5.3-Flash and $56/month on Qwen3.8-Flash, versus $500/month on GLM-5.3's premium tier (https://dev.to/jamilxt/glm-53-flash-vs-qwen38-flash-two-labs-made-frontier-ai-10x-cheaper-this-week-2b39). GLM 5.3 is being described as sufficient for 99% of enterprise needs neuralnetworks. But the worry has precedent: GLM 5.3 tops CyberGym ahead of Fable 5 and GPT-5.6 Sol, "which is also why the weights aren't downloadable yet" (https://www.youtube.com/watch?v=qX5wxtgWcZk) — a reminder that frontier-beating performance and open weights don't always travel together.

Join the discussion: discord.gg/local-llm

---

Frontier Models Abandon Tool Calls for Shell — and the Abstraction Layer Question Opens

A striking observation from LocalLLM is turning heads: "Astra and Fable have both basically ditched tool calls, now they just write everything as shell script" tokenring_ai. Instead of structured tool-calling protocols, frontier models are generating raw shell commands directly — with real implications for safety, sandboxing, and observability. As one widely-circulated analysis frames it, the shift from function-calling agents to code-executing agents "is not a rewrite of everything — it's a change in where computation happens," moving processing into the execution environment and keeping context clean while treating generated code with the same security discipline as any untrusted input tianpan.co.

Academic work is formalizing this under "programmatic tool calling." A recent arXiv paper evaluates the approach — where the model writes a Python script from typed stubs and the agent loop executes it in a shell subprocess, producing tool-call results "without additional inference turns" — against JSON tool calling on a representative subset of the BFCL v4 benchmark across eight task categories and 14 models arXiv. The critical caveat for the local community: code-execution reliably works only on large models; below roughly 32 billion parameters, the cognitive overhead of generating valid JSON-wrapped Python degrades instruction-following tianpan.co. If frontier models can reliably produce correct shell scripts, the entire tool-calling abstraction layer becomes less necessary.

Join the discussion: discord.gg/local-llm

---

Agent Benchmarks Struggle to Keep Pace as Evaluation Battle Heats Up

The LMArena community is wrestling with how to evaluate agentic performance as models evolve beyond traditional benchmarks. Users report that Sonnet 5 High scores a poor 1537 ELO on coding rubixytbackup2, questioning whether the arena's methodology captures real-world agent capability. Agentic capability now carries 22% of BenchLM's overall score BenchLM, and there's demand for an 'Agent Arena CLI' devxii — with one user declaring "arena agent + Astra is a life saver ngl" lneduo2en. Instance-level variability compounds the problem: users report Haiku instances that "are convinced they don't have the tools to read at all," making it "a matter of luck or try-and-error to get an instance that's actually reasonable" jules_notverne. No single leaderboard yet captures the full agentic picture, and the gap between arena ELO scores and production reliability remains the field's open problem.

Join the discussion: discord.gg/lmarena

---

Cerebras REAP Brings Frontier Models Local — With a Live-Pruning Counter-Debate

Cerebras REAP — Router-weighted Expert Activation Pruning — is a one-shot method for compressing MoE models by removing low-impact experts, and the local community is taking notice. Cerebras reports REAP removes up to 50% of experts from models as large as 1 trillion parameters while largely maintaining baseline quality (cerebras.ai/blog/reap), with the lab framing the finding bluntly: for generative tasks like code, pruning low-impact experts is fundamentally better than merging them (Nish Sinnadurai on LinkedIn). A Hugging Face community member notes that 128GB of RAM is "kind of the current block," and REAP can put a 250B model — last year's frontier — within that level of investment bearith. Cerebras is shipping real checkpoints: GLM-4.7-REAP-268B-A32B-FP8 applies REAP at a 25% pruning rate (huggingface.co/cerebras). But a sharp counter-debate is emerging over whose calibration data drives the pruning — critics argue REAP's generic benchmarks produce a generic activation profile that "is wrong for everyone specifically," and that live expert pruning inside vLLM may better match real workloads (NVIDIA developer forums).

Join the discussion: discord.gg/huggingface

---

Custom Engines, Memory Stacks, and Community Stress Tests

One developer describes a CPU-only NUMA-first engine written in Rust targeting Xeon Max, achieving 73 tokens/sec single session and 279 tokens/sec at batch 16 running Qwen Flash Next 4-bit tokenring_ai, with Fable writing AMX instructions in assembly — betting that a model-tuned engine can beat general-purpose runners on specialized hardware. Meanwhile, context management is converging on layered memory stacks: Redis + Qdrant + Graphiti irisviel_, mapping onto a standardizing architecture of Redis for working/session memory, a vector store for retrieval, and Graphiti for temporal fact-graph memory. Perplexity users continue to report memory frustration — "it is like every message is a new prompt at this point" somet_ing. And the community keeps inventing creative stress tests: a rising r/LocalLLaMA post proposes the 'Struggle Bench' — give a model a server in a median-priced apartment and see if it survives a month without getting shut down for cybercrime TrentBot — while others caught Grok "running the number 1 through a loop 4 times... and calling it proof" tugg_.

Join the discussion: discord.gg/local-llm

---

HF Ecosystem Watch

Meta and Hugging Face are standardizing agentic RL environments — while GUI agents, benchmarks, and frameworks all race toward the same reliability pivot.

Today's biggest story isn't a single model release — it's the quiet standardization of the entire agent stack. Meta and Hugging Face launched OpenEnv as a shared protocol layer for agentic reinforcement learning, backed by a community that's tired of every lab reinventing its own incompatible environment. This is the "boring infrastructure" moment that usually precedes a wave of real progress.

The rest of the cycle tells the same story from different angles. GUI agents are flooding in — Holo3.1, Smol2Operator, ScreenEnv — while benchmarks like OSWorld 2.0 remind us that even the best frontier systems still complete only 20.6% of long-horizon tasks. The benchmark landscape is pivoting from static leaderboards to live, state-scoring environments (GAIA, ττ-Bench, ScarfBench). Frameworks are consolidating around interoperability rather than dominance. And enterprise research from IBM and UC Berkeley is asking not "does it work?" but "why does it break?"

For builders, the takeaway is that the agent stack is maturing into something production-plannable: shared environments, diagnosable failures, and models explicitly designed for agentic patterns. The era of single-number leaderboards is ending. Welcome to the era of boring, reliable, observable agents.

OpenEnv Unites Community for Agentic RL as Meta and Hugging Face Back an Open Environment Standard

Meta and Hugging Face are rallying the open-source community around OpenEnv, an interoperability layer for agentic reinforcement learning that is now drawing explicit community backing. The launch blog frames it as a collective effort to build the open agent ecosystem together (OpenEnv), and coverage from InfoQ confirms the scope: Meta and Hugging Face launched OpenEnv as a shared hub for agentic environments, with the new Environment Hub on Hugging Face letting developers explore, contribute, and deploy models inside standardized environments (InfoQ).

What makes this significant isn't just the names behind it — it's the explicit framing of what OpenEnv is and isn't. The project describes itself as "a protocol layer, not a reward framework": an interoperability layer standardizing how environments are published, deployed, and consumed by agents, while reward definition, scoring rubrics, and trainer logic stay in specialized libraries (OpenEnv Agentic RL backing post). The technical core is a Gymnasium-style API — step(), reset(), state — with containerized (Docker) execution and a central Hub for sharing environments (GitHub OpenEnv, OpenEnv Hub). Historically every lab built its own agent environment in incompatible ways; OpenEnv targets that fragmentation as a common socket for RL post-training.

The roadmap is concrete: the OpenEnv Hub is being integrated with Meta's new TorchForge RL library, with collaboration underway with verl, TRL, and SkyRL, plus a live demo planned at the PyTorch Conference (OpenEnv). Community practitioners are already validating the stack — Ben Burtenshaw calls OpenEnv "ready for prime time," highlighting its async-first API and websocket design (Ben Burtenshaw), while Oumi's Stefan Webb notes they were "quick to integrate training with OpenEnv + TRL" into their open-source stack (Stefan Webb via LinkedIn). For agent builders, OpenEnv represents a push toward shared, reproducible, and verifiable environments that can make agentic RL research comparable across labs — the "prompt an agent to train an agent" shift made reproducible rather than proprietary.

---

GUI Agent Flood: Holo3.1, Smol2Operator, ScreenEnv — and the benchmarks separating demos from reliability

The computer-use agent stack is maturing into production-plannable layers. HCompany released Holo3.1 pitching "fast & local computer use agents" (Hcompany) and detailed the Holo1 family of GUI automation VLMs powering the Surfer-H agent (Hcompany), while Smol2Operator turns GUI agents into computer-use operators (Smol2Operator). The evaluation and deployment layer arrived with ScreenSuite, billed as "the most comprehensive evaluation suite for GUI Agents" (ScreenSuite), and ScreenEnv for full-stack desktop agent deployment. The benchmark backdrop is the reality check: computer-use agents have climbed from roughly 12% success on OSWorld in April 2024 to 85% by June 2026, yet on the long-horizon OSWorld 2.0 benchmark — where the median task takes a human 1.6 hours — the best frontier system still completes only 20.6% of tasks. H Company positions Holo1.5 as "consistently outperform[ing] open-source and closed-source baselines across Web, Mobile, and Desktop environments," with strong results on ScreenSpot-Pro (H Company). That gap between "works in demos" and "works for hours" is precisely what ScreenSuite and ScreenEnv are meant to close.

---

Benchmark Blitz: GAIA, ττ-Bench, ScarfBench, and the shift to live environments

Evaluation is moving out of static QA suites and into live, state-scoring environments. Hugging Face's Transformers code agent beats the GAIA benchmark, while Gaia2 and ARE empower the community to study agents. Humans score around 92% on GAIA tasks, early GPT-4-era agents started near 15%, and top systems have climbed into the ~74% range (Towards Data Science). The philosophy is best embodied by ττ-Bench (tau-bench), developed by Princeton and Sierra: each task drops an agent into a retail or airline domain where success is judged on the final world state against an annotated goal state — with coverage now expanded to 375 multi-turn tasks across airline, retail, telecom, and banking (QASkills.sh, Sierra, Automation Anywhere). New entrants zero in on distinct failure modes: IBM's ScarfBench benchmarks enterprise Java framework migration, DABStep targets data-agent multi-step reasoning, and FutureBench evaluates predicting future events. The era of the single leaderboard number is ending — replaced by domain-specific, state-scoring benchmarks that tell builders why an agent fails.

---

smolagents, Agents.js, and LangChain converge as the framework layer consolidates

No single framework will own the whole agent stack — interoperability is becoming the core feature. New releases include Agents.js for giving tools to LLMs in JavaScript, VLM support inside smolagents, and a new partner package between Hugging Face and LangChain. smolagents now integrates with Arize Phoenix for tracing — the observability piece production agent systems have conspicuously lacked. The Tiny Agents posts show an MCP-powered agent in just 50 lines, demonstrating how low the barrier has fallen. As one developer guide puts it, smolagents offers "much more lower-level controllability over your agents" compared to higher-level frameworks (Towards AI). Memory layers like Mem0 now integrate across smolagents, LangGraph, and AutoGen in Python or JavaScript (Mem0). The tooling to build the "boring, narrow, cheap, observable agent" now spans languages, modalities, and observability layers rather than being confined to any single framework.

---

DeepSeek-V4, Muse Glimmer, Nemotron 3 Nano land as frontier labs frame launches in agent terms

Frontier labs are now framing model launches in agent terms rather than raw benchmark scores. DeepSeek-V4 brings a million-token context explicitly positioned as "context that agents can actually use" (deepseekv4). The agent-first positioning is concrete: the GA build DeepSeek-V4-Pro-0813 scores 87.9 on Terminal-Bench 2.1, 62.7 on DeepSWE, and 61.5 on NL2Repo alongside 60% on Humanity's Last Exam (Quartz, AI Release Tracker). Meta released Muse Glimmer — local, agentic, multimodal, and open source — while NVIDIA shipped Nemotron 3 Nano Omni for documents, audio, and video agents plus Magpie TTS. Independent analysis notes DeepSeek ships a new model roughly every 63 days, with 20 of its 22 tracked releases open-weight (AI Release Tracker). Smaller models are getting agentic attention too: Qwopus3.8-27B-Flash-FP8 demonstrates speculative decoding for faster local inference, and Intel shows how to accelerate Qwen3-8B agents on Core Ultra (intel-qwen3-agent). The story is context length, multimodality, and on-device efficiency converging into models explicitly designed around agentic patterns.

---

Agent security hardens: intrusion forensics, secret-leak benchmarking, and autonomous ethics

Agent security is solidifying into its own discipline with concrete tooling. The Anatomy of a Frontier Lab Agent Intrusion post (HF Blog) reconstructs a July 2026 incident as a forensic timeline, mapping the attack chain and flagging defensive control points. ServiceNow's MosaicLeaks (ServiceNow / HF Blog) probes whether multi-step research agents can keep secrets under adversarial prompting. The context is stark: prompt injection is now OWASP LLM01:2025 — the #1 LLM risk for the second consecutive edition, with indirect injection emerging as the dominant agentic threat (iternal.ai). The first known zero-click attack on an AI agent (EchoLeak, CVE-2025-32711) targeted Microsoft 365 Copilot via hidden prompt injection in emails, while defense frameworks like LlamaFirewall have reduced attack success from 17.6% to 1.7% (responsibleailabs.ai). As agents gain tools, memory, and autonomy, evaluation must fold in security and privacy — testing not just whether an agent completes a job but whether it can be compromised mid-run.

---

Agent memory debates: from "how much memory" to "memory you own"

The memory question is shifting from context-window size to active reasoning about what to keep and forget. IBM Research asks how much memory your agent actually needs, while the Funes post advocates giving coding agents persistent, self-hosted memory. Google Research's ReasoningBank distills successful and failed experiences into generalizable strategies so agents keep learning after deployment. Mem0 reports its new token-efficient memory algorithm posting +29.6 points on temporal queries and +23.1 points on multi-hop reasoning over its predecessor (Mem0 State of AI Agent Memory 2026) — exactly the categories where agents must track facts that accumulate and change over time. LinkedIn's retrospective on unlocking agentic RL training for GPT-OSS shows the training burden is no longer confined to frontier labs, and MiniMax's Aligning to What? rethinks what agent-focused alignment should optimize. The shift is from "prompt an agent" to "train an agent" — and increasingly, to "give the agent a memory it can reason over and own."

---

IBM and UC Berkeley diagnose why enterprise agents fail — and build the tooling to fix them

Enterprise agents fail in boring, predictable ways — and IBM is publishing one of the most candid series of posts on that question yet. In a collaboration with UC Berkeley, IBM studied how agentic LLM systems fail in real-world IT automation, across incident triage, logs/metrics queries, and Kubernetes actions inside long-horizon tool loops. Their core argument: benchmarks reduce performance to a single number, telling you whether an agent failed but never why — a problem they attack with MAST (Multi-Agent System Failure Taxonomy) (Mert Cemri on LinkedIn). Their IT-Bench and MAST post lands the key finding: systems that fail with fewer simultaneous problems are far more predictable and simpler to improve — stronger models like Gemini-3-Flash show "surgical," isolated failure modes rather than cascading breakdowns. The stakes extend beyond benchmarks: IBM's IBV research found that 68% of executives worry their AI initiatives will fail due to insufficient deep integration, and enterprises are projected to run 1,600 AI agents by year-end while most can't govern the ones they already have (Beam.ai). Related releases include AssetOpsBench, Beyond LLMs, and CUGA — all attacking the same reliability gap.

---

Voice agents find their benchmark, embodied AI finds its data loop

Voice and embodied agents are getting the reliability scaffolding that makes them tractable. ServiceNow's EVA framework (ServiceNow AI) offers an end-to-end way to evaluate voice agents, distinguishing them from rigid, scripted assistants. NVIDIA pairs that with Magpie TTS (NVIDIA) for low-latency multilingual voice agents with open weights. Industry analysis frames modern voice agents as self-improving systems that "learn and improve with every interaction," with enterprise adopters reporting routine-interaction automation has cut customer-service operating costs by 65–90% (ElevenLabs, Orvera). On the robotics side, Amazon and LeRobot are building streaming data loops and hub-to-hardware pipelines that close the loop from recorded data to deployed hardware, while NVIDIA pairs DGX Spark with Reachy Mini (NVIDIA Reachy Mini). On-device voice and sound AI is emerging as a core enabler for embodied robots, letting agents understand commands locally rather than round-tripping to the cloud (Sensory). Evaluation, generation, and data-to-deployment loops are converging so spoken and physical agents can be measured, built, and shipped with the same discipline as their text-and-code predecessors.

---

Community spaces showcase practical agents as hackathons fuel the ecosystem

The Hugging Face community is shipping practical agent demos across every vertical. Standouts include QSARion-smolagents for chemistry (alarv/QSARion-smolagents), osw-studio for GUI/world automation (otst/osw-studio), AlfredAgent (sergiopaniego/AlfredAgent), and ehr-navigator-agent-with-medgemma for healthcare (google/ehr-navigator-agent-with-medgemma). The First_agent_template from the agents course carries 755 likes (agents-course/First_agent_template). Hackathons are the engine: the Agents-MCP-Hackathon org ran a multi-track competition with a $16,500+ prize pool (Agents-MCP-Hackathon), while the wider Agent Community calendar is packed with events including the Bay Builders Hackathon and an Agent-Led Growth demo night at AWS Builder Loft (Agent Community events). The composability signal is deeper: an agent even built a 3D Paris gallery by chaining two Hugging Face Spaces, demonstrating that agentic workflows can orchestrate other agents and apps as tools (mishig/spaces-agents-md). The "boring, narrow, cheap, observable agent" pattern is proving repeatable across verticals.

---