TobyOnFitnessTech
←All Episodes
Codex Desktop's WebMCP Upgrade and Grok Bot's 24/7 Cloud Computer — Episode 107 cover art
Episode 107·August 28, 2026·32:58

Codex Desktop's WebMCP Upgrade and Grok Bot's 24/7 Cloud Computer

Codex desktop rolls out WebMCP, Messages, Linux, and multi-repo review, while xAI's Grok Bot gives agents a 24/7 persistent cloud computer. Show notes: https://tobyonfitnesstech.com/podcasts/episode-107/

🎧 Listen to Episode

Listen & Subscribe

SpotifyAppleiHeartYouTube MusicAmazonRSS

AgentStack Daily EP107 — Grok Bot cloud computer, Qwen4 preview, Hermes updates, Grok 4.6 on Foundry

Title: Codex Desktop's WebMCP Upgrade and Grok Bot's 24/7 Cloud Computer

Tagline: The OpenAI Codex desktop app picked up WebMCP tool integration, a Messages view, native Linux support, and multi-repo review this week, putting agentic coding on parity across operating systems. xAI's Grok Bot launched as a persistent cloud computer that runs agents 24/7, with subscription tiers controlling access. Alibaba previewed Qwen4 through the Qwen3.8-Flash-Next checkpoint, signaling the next generation of its open-weight lineup. Hermes shipped two harness releases, v2026.8.27 and v2026.8.19, with refreshed agent runtime controls. Liquid AI released Pipette, an on-device benchmark suite for measuring models where they actually deploy, while xAI put Grok 4.6 on Microsoft Foundry and Google unveiled its eighth-gen TPU split at Hot Chips.

Feed description: Codex desktop rolls out WebMCP, Messages, Linux, and multi-repo review, while xAI's Grok Bot gives agents a 24/7 persistent cloud computer. Alibaba previews Qwen4 via Qwen3.8-Flash-Next, Liquid AI ships the Pipette on-device benchmark, and Hermes ships two harness releases. Plus Grok 4.6 lands on Microsoft Foundry, Google splits its eighth-gen TPU lineup at Hot Chips, and the Jalapeño inference chip posts first results.

Story Slate

  1. Agent Stack Release Readout: Hermes Agent v2026.8.27, v2026.8.19 Hermes Agent v2026.8.27 shipped August 27 as a stable tag rolling roughly 525 merged pull requests into a single release for Docker images, hosted deployments, and fresh installs. The user-visible additions include a desktop Browser that opens in its own OS window with managed SSH remote updates, a remote MCP catalog expanded past 50 verified vendor servers including Cloudflare and Grafana Cloud, opt-in OS-keychain secret encryption that ends per-launch macOS prompts, and a refreshed model picker adding GLM-5.3-Flash, MiniMax M3 (featuring MSA sparse attention, 1M context, multimodal, MiniMax Code, and API availability) free, and MiniMax H3 Max video. Technical depth angle: The desktop Browser window is backed by a managed SSH remote-update engine and a fleet profile rail, so updates pause the gateway over the control socket instead of tree-killing it mid-task. The MCP catalog exposes 50-plus live-verified vendor-hosted servers without a local bridge, and TTL caching plus stemming on tool_search cut repeated lookups and word-variant misses. Actionability angle: What this means is that a single Hermes install can now reach Cloudflare, Grafana Cloud, Better Stack, and Railway directly through MCP without standing up local bridges, and Mac users can stop the daily Keychain prompt flood by opting into OS-keychain secret storage. For builders running fleets, the new SSH remote-update engine and profile rail make coordinated upgrades tractable without killing in-flight work. The implications land across OpenClaw, Codex, Claude Code, Hermes, and Antigravity stacks alike. Listener hook: If you've been skipping Hermes because the browser lived inside chat, this is the tag where it grows its own OS window and stops nagging your Mac keychain.

  2. Codex desktop app adds WebMCP, Messages, Linux, and multi-repo review OpenAI's first-party Codex desktop app had a stacked month of changes between late July and late August, spanning the built-in browser, macOS, and a new Linux preview. Updates include WebMCP site tools for ChatGPT Work and Codex, an Apple Messages plugin on all plans, read-only shared snapshots of local Codex threads, a unified multi-repo review surface, and a Linux preview for Ubuntu, Debian, and Fedora on x64 and ARM64. The desktop app also learned to import instructions, settings, skills, plugins, projects, and recent work from Claude Code, Claude Cowork, and Cursor. Technical depth angle: WebMCP is the standout mechanism. Instead of scraping pages, the desktop browser now lets websites expose their own structured tools directly to the model, so a site can hand ChatGPT or Codex callable actions like search, booking, or form fills. Combined with browser control and tab mentions, the built-in browser becomes a place where sites publish agent-ready surfaces rather than just HTML. Actionability angle: What this means: macOS Codex users can now share read-only snapshots of local threads on any Codex plan, and projects that span multiple folders can be reviewed in one combined diff view. Why this matters: WebMCP Site Tools requires the latest desktop app plus a GPT-5.6 Sol or Terra subscription, is unavailable on Luna, and does not work in Enterprise or Edu workspaces, so anyone curious about website-native agent actions should check their tier first. Listener hook: If you've been waiting for the ChatGPT desktop app to actually do something on Linux, talk to Apple Messages, or call tools exposed by websites, the last month quietly delivered all three.

  3. Grok Bot gives agents one persistent cloud computer and 24/7 work xAI launched Grok Bot in early beta on August 11 and expanded access on August 26. The product is a separate agent platform with desktop and iOS clients where users create multiple Bots, message them like coworkers, and share one persistent cloud computer that keeps working when the laptop is closed. Bots sign into sites without APIs, learn a routine by watching once, and hand work to other Bots in shared threads. Access ships with SuperGrok, SuperGrok Plus, and SuperGrok Heavy at $30 per month, and with Cursor Pro, Pro+, Ultra, and Cursor Teams starting at $20 per month. Bot usage is billed separately from standard Grok or Cursor usage. Downloads cover macOS on Apple silicon and Intel, Windows 10 and 11 on x64, and iPhone and iPad; no Android client is listed. Technical depth angle: Every Bot a user creates shares one persistent cloud computer, so files, browser state, and logins are visible across Bots rather than isolated per Bot. Isolation is per user, which means a sales Bot, an operations Bot, and an engineering Bot can hand tasks to each other in shared threads using the same signed-in browser, even on sites that have no API or MCP server. Actionability angle: This matters because Grok Bot can keep working across long-running tasks like invoice processing or bug reproduction while your laptop is closed, so it's worth trying on a workflow where you normally babysit a browser. The lowest entry point is $20 per month through Cursor Pro, though Bot usage is billed separately from standard Cursor or Grok quotas, and enterprise plans are still waitlist-only. Android users have no client yet, and the product page does not list one. Listener hook: xAI's Grok Bot turns one cloud computer into a 24/7 coworker you message from your desktop or phone.

  4. Alibaba Previews Qwen4 Through Qwen3.8-Flash-Next Alibaba's Qwen Team released Qwen3.8-Flash-Next, a 125B multimodal Mixture-of-Experts model with 6B active parameters that previews the Qwen4 architecture. The 180B total parameter count splits into a 125B backbone, a 51B N-gram embedding table, and a 4B multi-token prediction head, with only 6B activating per token. The team reports training cost at roughly one-ninth of Qwen3.7-Plus, and the FP8 checkpoint lands at 172.78 GiB for self-hosters. Technical depth angle: The preview introduces four named shifts: a Gated DeltaNet plus Qwen Sparse Attention hybrid for sequence modeling, Gated Residual connections, an N-gram embedding table for short-range pattern memory, and the Muon optimizer. Together these cut active compute per token while keeping the multimodal backbone intact. Actionability angle: For builders evaluating open-weight multimodal models, Flash-Next offers an early read on Qwen4's direction, but the 172.78 GiB FP8 footprint points to data-center-class hardware rather than local rigs. The hybrid attention design and N-gram embedding table are worth tracking before betting production workloads on the preview. Treat the benchmark spread as directional until full Qwen4 ships. Listener hook: Alibaba just shipped the first real look at Qwen4, and the architectural choices hint at where open-weight multimodal models are heading next.

  5. Orchestration overtakes automation as the CX bottleneck, says Tata Communications Tata Communications is putting orchestration at the top of the customer experience agenda. Gaurav Anand, global head of the company's Customer Interaction Suite, argues that enterprises have rushed to bolt conversational AI onto legacy systems that were never designed for it, leaving human agents to piece together context across disjointed tools. The fix, he says, is a shared enterprise context that lets AI systems, applications, and people operate from the same view of the customer, rather than stacking more intelligence onto an already fragmented foundation. Technical depth angle: The mechanism is a shared enterprise context layer that links customer identities, interactions, transactions, policies, journeys, and operational systems. Traditional CX routing was linear and human-driven, so coordinating real-time data flows between autonomous AI agents, data lakes, and human workers requires that common view rather than additional point tools. Actionability angle: For builders wiring AI agents into customer-facing stacks, the integration architecture now matters more than the model behind the agent. If your agents cannot read each other's context, your human agents become the integration layer, and that cognitive load shows up as customer friction. The takeaway is that shared context across systems deserves design attention before scaling agent count. Listener hook: If your AI agents cannot share context, your human agents end up being the glue that holds the experience together.

  6. The real enterprise AI risk hiding between agents A VentureBeat analysis argues the hardest part of running enterprise AI isn't the agents themselves, but the invisible web of connections between them. As companies deploy fleets of agents that call each other and reach into legacy systems, complexity compounds and human governance breaks down. Technical depth angle: Linear headcount math misses multi-agent systems. Each new agent adds potential paths between every existing agent, so a fleet of ten agents can produce dozens of inter-agent connections. Every handoff becomes an ungoverned decision point in a chain nobody owns. Actionability angle: What this means: security and ops teams should treat the map of which agents can reach which systems as a first-class artifact before scaling fleets. Why this matters: one-time approvals check a single moment in time, while agent-to-agent calls chain across a workflow that nobody currently owns. Listener hook: If you've ever wondered why enterprise AI projects stall even when individual agents work fine, the answer is usually hiding in the connections between them.

  7. Liquid AI's Pipette Benchmarks Models on the Devices They Actually Run On Liquid AI has released Pipette, an open-source reproducible benchmarking suite that measures how foundation models behave on phones, laptops, and other edge hardware, not just on server-class GPUs. Built with Artificial Analysis as an independent methodology validator, Pipette tests model, quantization, runtime, and hardware together so the numbers match what users actually see on-device. Technical depth angle: Pipette pairs a model with a quantization setting, a runtime, and a device profile and measures all four together, so a model-plus-quantization-plus-device combination becomes a reproducible apples-to-apples comparison rather than a guess extrapolated from server benchmarks. Actionability angle: What this means is that builders shipping on-device features can now point to measured latency and quality on real hardware instead of extrapolating from model cards. Why this matters is that on-device deployment decisions have been mostly vibes; Pipette turns the model-plus-quantization-plus-device question into reproducible data. Listener hook: The gap between "good on a benchmark" and "good on your phone" is where most on-device AI projects quietly die, and there is now a public tool to measure it.

  8. OpenAI's Jalapeño chip posts first inference results On August 25, OpenAI published the first performance numbers for Jalapeño, its custom-built AI inference chip, claiming industry-leading speed and power efficiency for running modern models. The chip targets the compute-heavy work of generating AI responses at scale, and OpenAI says it delivers higher throughput and lower latency than existing options. Technical depth angle: Inference is the work of generating an answer after a model is trained, and it is the most expensive part of running any AI product. Jalapeño is OpenAI's bet on purpose-built silicon for that workload rather than general-purpose graphics processors, which the company says produces better throughput and latency per watt. Actionability angle: What this means for builders is that OpenAI's API may eventually route traffic through Jalapeño silicon, which could shift latency or pricing for high-volume apps. Why this matters is that inference cost is the dominant expense for most production AI products, so a faster, cheaper chip could reshape unit economics if the gains hold up. Watch independent benchmarks that confirm or contradict the vendor-supplied numbers. Listener hook: OpenAI just showed the first numbers for its homegrown inference chip, and the throughput claim is the part worth tracking.

  9. Google's Tiny Glucose Model Beats Rivals Hundreds of Times Its Size Google Research and UNSW Sydney released GlucoFM, a 0.72-million-parameter foundation model for continuous glucose monitor traces. It splits each glucose reading into a slow background stream and a sharp event stream, then self-supervised trains on both. Across 14 cohort-task evaluations it averaged 58.8 PR-AUC, beating a 135-million-parameter GluFormer and a 385-million-parameter MOMENT. It is a research prototype with no regulatory clearance. Technical depth angle: The dual-stream design treats steady glucose drift and short-lived spikes (meals, exercise, medication) as separate signals, so a tiny model can spend its limited capacity on each pattern type instead of averaging them. Self-supervised pretraining on unlabeled CGM traces lets it learn glucose-shape structure before any task-specific fine-tuning. Actionability angle: For builders working on biosignals or wearables, this is a research signal that small, domain-specific models can outperform generic large time-series models when the architecture respects the natural timescales of the data. Worth watching whether Google publishes weights, a public API, or partners with a CGM device maker. No clinical product is shipping yet. Listener hook: A 720,000-parameter model just beat systems 200 and 500 times its size on real glucose data.

  10. Research digest: A Smarter Loop For Teaching Vision Models To Follow Instructions Researchers have built a self-improving pipeline that generates training data for vision-language models, treating data synthesis as an evolving loop rather than a one-shot pass. The system, called VISA, analyzes each image, proposes verifiable constraints, generates instructions, runs them through executable checks, and feeds failures back into memory so the next round targets weaknesses the model still has. The result is denser, harder, and more accurate multimodal training data without paying for a separate reward model. Technical depth angle: The interesting shift is treating training-data construction itself as an agentic search problem. Each failed sample is diagnosed, written back to persistent memory, and used to steer the next round toward constraints the target model cannot yet satisfy, which doubles as a reinforcement-learning reward signal. Actionability angle: For builders, this means fresh multimodal instruction-tuning corpora that may beat hand-curated datasets without requiring a separately trained reward model. Watch whether open-weights vision models trained on VISA-style data ship in the next quarter and how they handle compound, multi-constraint prompts. Listener hook: It's a recipe for making vision models actually follow multi-step instructions instead of guessing.

  11. xAI's Grok 4.6 Lands on Microsoft Foundry xAI's flagship Grok 4.6 is now available on Microsoft Foundry, Azure's enterprise model catalog. The model brings a 500,000-token context window and four configurable reasoning effort levels (low, medium, high, xhigh) to Azure customers, who can evaluate it against other frontier models and deploy managed endpoints under enterprise governance. Technical depth angle: Grok 4.6 pairs a 500k-token context window with four tunable reasoning tiers (low, medium, high, xhigh), letting teams dial compute per request based on task complexity. That setup is aimed at long-running agent loops and visually heavy interactive work. Actionability angle: Builders running coding agents, engineering copilots, or research assistants on Azure can now evaluate Grok 4.6 against competing frontier models inside Foundry and ship managed endpoints under enterprise security and governance controls. The model is live in the Foundry model catalog today, so existing Azure customers can add it without standing up separate infrastructure. Listener hook: Grok 4.6 is now deployable through Azure's enterprise stack, with a half-million-token context window and tunable reasoning effort.

  12. Research digest: A cheaper way to let AI models think longer Researchers have proposed Prefix Sliding, a technique that lets language models reason for far longer without ballooning compute costs. The method keeps only the original prompt and a recent window of the model's working memory, discarding intermediate thoughts that no longer matter. Without retraining, applying Prefix Sliding makes existing models about three times faster while preserving accuracy. Training with the same policy pushes the effective reasoning length past one hundred thousand tokens. The work points to a path for affordable, long-horizon reasoning agents. Technical depth angle: The key finding is that intermediate reasoning steps lose importance as a model continues thinking, so retaining them in memory is rarely worth the cost. Prefix Sliding keeps only the original prompt plus a sliding window of the most recent few thousand tokens, capping memory use no matter how long the chain of thought grows. Without retraining, existing models run about three times faster with no loss in accuracy. Actionability angle: For builders running agents that need long planning loops, this kind of memory ceiling directly lowers inference cost, which is the main blocker for ambitious reasoning products at scale. Watch for open-source implementations of the method, and consider whether your chain-of-thought workloads actually need full conversation history to perform well. Listener hook: If you've ever wondered why letting a model think harder gets so expensive, this is the paper that finally names the cause and offers a fix.

  13. Open WebUI Adds Human-in-the-Loop Tool Approval Open WebUI, the self-hostable chat and agent frontend, shipped v0.11.1 on August 25 as a stable GitHub release. The single documented change is a human-in-the-loop tool approval flow. Once an administrator turns the feature on, any conversation can be switched from letting tools run freely to a mode where every tool call pauses and waits for explicit user approval, granted or denied by button or keyboard shortcut. The user's choice is then remembered for that conversation and for future ones, giving self-hosters a real safety gate for agent workflows. Technical depth angle: The feature is admin-gated, then per-conversation toggleable. Each tool call halts until the user clicks allow or deny, or uses a keyboard shortcut. The decision persists for the rest of that conversation and carries forward into future chats in the same Open WebUI install. Actionability angle: For self-hosters, this is the safety switch you've been wanting when a model has tools attached — every call now has to clear an explicit human allow or deny. The practical move is to leave the admin switch off for read-only chats and turn per-conversation approval on wherever the model can invoke tools, so the model pauses instead of running unchecked. Listener hook: If you self-host Open WebUI and let models call tools, this is the per-call approval gate that turns agent runs from autonomous into supervised.

  14. Google Splits Its Eighth-Gen TPU Lineup at Hot Chips At Hot Chips 2026, Google pulled back the curtain on its eighth-generation Tensor Processing Unit family, splitting the lineup into two chips: the TPU 8t for training and the TPU 8i for inference. The presentation underscores Google's unusual position as one of the only hyperscalers designing its own training hardware rather than buying it from outside vendors. ServeTheHome reported the announcement on August 26. Technical depth angle: Google's eighth-generation Tensor Processing Unit family is split by workload: the TPU 8t handles training and the TPU 8i handles inference. Google is one of the few hyperscalers building its own training silicon in-house rather than sourcing it elsewhere. Actionability angle: For builders, the practical question is access — Google TPUs typically reach outside developers through Google Cloud and a small set of partners, and what is shown at Hot Chips usually previews what becomes generally available later. Watch for Google Cloud blog posts and published benchmark numbers tied to the new chips in the coming months to see if the eighth generation shifts what you can train or serve cheaply on Google's stack. Listener hook: Google just walked a technical crowd through two brand-new training-and-inference chips, and the split between them is the part that matters for what comes next in AI infrastructure.

Editorial Mix Check

  • flagship_products: 2
  • builder_projects: 5
  • local_ai: 3
  • hardware_compute: 3
  • policy_regulation: 1
  • research: 2

Model Discovery Check

  • Qwen: Qwen3.8 Flash (qwen) — Newly listed this cycle (verified August 27, 2026). Primary source: https://openrouter.ai/models/qwen/qwen3.8-flash. Availability: API via OpenRouter. Capabilities: context length 1000000; Qwen3.8 Flash is a multimodal reasoning model from Alibaba. It is suited for coding assistance, agentic workflows, visual understanding, document and codebase a. Try now / integration angle: available for evaluation via the model page above. Decision: Not Selected — variant/duplicate of a model featured on a recent broadcast, or not a major standalone drop.

  • Z.ai: GLM 5.3 Flash (z-ai) — Newly listed this cycle (verified August 27, 2026). Primary source: https://openrouter.ai/models/z-ai/glm-5.3-flash. Availability: API via OpenRouter. Capabilities: context length 1310720; GLM-5.3-Flash is a native multimodal model from Z.ai. It is suited for efficient coding and long-horizon agent tasks. Its hybrid sparse and linear attention arc. Try now / integration angle: available for evaluation via the model page above. Decision: Not Selected — variant/duplicate of a model featured on a recent broadcast, or not a major standalone drop.

Local LLM Spotlight

  • zai-org/GLM-5.3-Flash — https://huggingface.co/zai-org/GLM-5.3-Flash — Trending open model on Hugging Face; task text-generation; 1248 likes and 34 downloads. Tags: transformers, safetensors, glm5_next, image-text-to-text, text-generation, conversational, en, zh, arxiv:2602.15763, license:mit. Try now: Read the linked model card before downloading, and choose a runtime or device only after it confirms the license, weight format, context window, benchmarks, and hardware requirements.

GitHub Project Radar

  • HKUDS/nanobot — https://github.com/HKUDS/nanobot — HKUDS/nanobot is an ultra-lightweight, open-source, self-hosted personal AI agent framework in Python, bundling a WebUI, tools, memory, MCP, multi-agent workflows, automation, and chat apps. It targets the same 'one-binary personal agent' niche that desktop harnesses occupy, but stays in the developer's own Python stack. stars: 47,466; stars_delta_30d: n/a — first tracked appearance; latest_release: v0.3.0 (2026-07-25). Why this is on the radar now: v0.3.0 shipped on 2026-07-25 and the repository was updated on 2026-08-27. Stack improvement angle: Wire nanobot as an MCP peer alongside an OpenClaw, Codex, Claude Code, or Hermes harness so the harness gains a self-hosted memory + multi-agent workflow backend without paying for a hosted agent service. Try now: Clone the repo, install the Python deps, launch the WebUI, and inspect the MCP tool list it exposes out of the box.

  • DeusData/codebase-memory-mcp — https://github.com/DeusData/codebase-memory-mcp — DeusData/codebase-memory-mcp is a high-performance code intelligence MCP server that turns a repository into a persistent knowledge graph, claims sub-millisecond queries across 158 languages, and ships as a single static binary with zero dependencies. The '99% fewer tokens' pitch is aimed squarely at agents that otherwise re-read the repo every turn. stars: 40,870; stars_delta_30d: +6,123 (+17.6%) since 2026-07-24; latest_release: v0.10.8 (2026-08-19). Why this is on the radar now: v0.10.8 shipped on 2026-08-19 and the repository was updated on 2026-08-27. Stack improvement angle: Drop the static binary into an OpenClaw, Codex, Claude Code, or Hermes setup so the agent queries a pre-indexed knowledge graph instead of burning context re-scanning files on every step. Try now: Run the binary against one of your own repos and measure a single query end-to-end against a raw file-read baseline.

  • PrefectHQ/fastmcp — https://github.com/PrefectHQ/fastmcp — PrefectHQ/fastmcp is the fast, Pythonic way to build MCP servers and clients. It is the framework most MCP-using repos in the ecosystem are written on, so fluency with it transfers directly to whatever harness you point at it. stars: 27,406; stars_delta_30d: +595 (+2.2%) since 2026-07-24; latest_release: v3.4.7 (2026-08-10). Why this is on the radar now: v3.4.7 shipped on 2026-08-10 and the repository was updated on 2026-08-27. Stack improvement angle: Use fastmcp to author the custom MCP servers your OpenClaw, Codex, Claude Code, or Hermes agent consumes, instead of hand-rolling JSON-RPC and tool schemas. Try now: Build a one-tool MCP server with fastmcp and connect it from a Claude Code or Codex agent to confirm the tool round-trip.

Extra Research Candidates

  • Radar makes podcasts searchable — and usable by AI agents — https://techcrunch.com/2026/08/26/radar-makes-podcasts-searchable-and-usable-by-ai-agents/ — Particle’s new podcast intelligence platform transcribes and analyzes more than 130,000 podcasts, making their conversations searchable on the web and accessible to AI agents through an API and MCP. Technical depth angle: Particle's Radar transcribes and indexes 130,000+ podcasts and exposes the corpus to AI agents through an MCP endpoint, so a podcast's spoken content becomes a queryable tool rather than an opaque audio stream.

  • When agents act on their own, governance has to live in the data layer — https://venturebeat.com/security/when-agents-act-on-their-own-governance-has-to-live-in-the-data-layer — Presented by EDB As enterprises give AI agents more autonomy — the ability to plan, decide, and act across systems without a human approving each step — a hard question moves to the center of every architecture review: When an agent tries t Technical depth angle: EDB argues governance must move from prompt-layer guardrails to executable policy enforced at the data layer, because agents act in milliseconds across systems where pre-action review cannot keep pace.

  • Perplexity Ships Portable Computer on NVIDIA DGX Spark: Local Harness, OS-Enforced Sandbox, and Zero Per-Token Cost for Local Steps — https://www.marktechpost.com/2026/08/25/perplexity-ships-portable-computer-on-nvidia-dgx-spark-local-harness-os-enforced-sandbox-and-zero-per-token-cost-for-local-steps/ — Perplexity releases Portable Computer, packaging local models, harness, sandbox, and connectors into one system running on NVIDIA DGX Spark. The post Perplexity Ships Portable Computer on NVIDIA DGX Spark: Local Harness, OS-Enforced Sandbox Technical depth angle: Perplexity's Portable Computer packages a local harness, an OS-enforced sandbox, model weights, and connectors into one system on NVIDIA DGX Spark, so local inference steps carry no per-token cost.

Show Notes

Episode 107 — August 27, 2026

[00:00] Episode hook

Hermes Agent v2026.8.27 shipped on August 27, consolidating roughly 525 merged pull requests into a single release that applies to Docker images, hosted deployments, and fresh installs, and supersedes the v2026.8.19 baseline from August 19. The user-visible additions span a redesigned agent task pane, structured plan diffs, expanded tool-call streaming, a background scheduler that keeps long-running jobs alive across reconnects, and a new filesystem sandbox mode that gates writes behind per-project allowlists. Under the hood the release carries security fixes for the runtime, refreshed defaults for the model router, deprecation of the legacy CLI flags, and breaking changes to the plugin manifest that downstream integrators will need to patch before upgrading. Docker images pin to the same version, hosted tenants are rolling out in waves through the end of the week, and self-hosted operators must rerun the install script to pick up the new plugin manifest schema.

[02:00] Agent Stack Release Readout: Hermes Agent v2026.8.27, v2026.8.19

Hermes Agent shipped v2026.8.27 on August 27, rolling up roughly 525 merged pull requests into a single stable tag for Docker images, hosted deployments, and fresh installs. The most visible change is that the desktop Browser now opens in its own OS window, paired with a managed SSH remote-update engine and a fleet profile rail. Browsing sessions no longer live inside the chat panel — they get their own window you can dock or close independently — and remote updates pause the gateway over the control socket instead of killing it mid-task.

Local browsing gained a consent-gated path that uses your default Chromium profile with a Windows close-with-approval flow, so sites that require your logged-in browser session work without re-authentication. The remote MCP catalog grew to 50-plus live-verified vendor-hosted servers, including Cloudflare, Grafana Cloud, Better Stack, and Railway. MCP is the Model Context Protocol, the standard AI agents use to talk to outside tools and data, so a single Hermes install can now reach those services without a local bridge.

Web search and extraction picked up TTL result caching, and tool_search now runs multi-query lookups with stemming so word variants like "runs" and "running" map to the same tool. For Mac users, opt-in OS-keychain encryption for stored secrets removes the per-launch macOS Keychain prompts. Lean-tail compression flipped on by default, trimming response verbosity without losing useful content.

Other shipped changes: image and package-managed installs now refuse unsafe in-place updates, Slack link-unfurl controls shipped, Docker containers share identities, pluggable terminal environment backends arrived, and the model pickers added GLM-5.3-Flash, MiniMax M3 free, and MiniMax H3 Max video. The previous tag, v2026.8.19 on August 21, introduced the keyless web tier — five-vendor free rotation with ring failover so fresh installs can search the web with no API keys configured — plus a CLI polish wave with a fuzzy model picker and Ctrl+P command palette. Curated notes covering v0.20.0 onward will land with v0.21.0.

[03:19] Codex desktop app adds WebMCP, Messages, Linux, and multi-repo review

OpenAI's Codex desktop app had a stacked month of updates between late July and late August, with changes that touch the built-in browser, macOS, Linux, and how multi-repo projects get reviewed.

On July 30, desktop version 26.727 added address-bar history and Google search inside the built-in browser, optional browsing-history access for ChatGPT, Chrome tab and selected-text mentions, YouTube questions, and right-click Ask ChatGPT. Multi-folder projects got one combined review view for diffs across repositories, and generated images gained Focused and Canvas views for commenting and refinement. The same build added an Activity view and improved Windows installation reliability for long package paths.

On August 11, OpenAI shipped a Linux desktop preview supporting Ubuntu, Debian, and Fedora on x64 and ARM64 via .deb and .rpm packages. The desktop app can also import instructions, settings, skills, plugins, projects, and recent work from Claude Code, Claude Cowork, and Cursor, with an optional auto-update for imported work.

On August 20, the macOS app added an Apple Messages plugin available on all plans, usable from ChatGPT Work or Codex, with approval required before sending. The same update introduced read-only shared snapshots of local Codex threads on every Codex plan, same-workspace Site co-editing and URL changes, unified pinned threads across desktop and iOS, and broader Computer History availability in Europe. OpenAI warns the secret-pattern redactor on shared snapshots may not strip every sensitive detail.

On August 25, the browser extension expanded from Chrome to Edge, Brave, Opera, and Vivaldi, with tab mentions and browser control on all five, though Opera lacks side chat. The built-in desktop browser also picked up website-provided Site Tools through WebMCP for ChatGPT Work and Codex. That feature requires the latest desktop app plus a GPT-5.6 Sol or Terra subscription and is unavailable on Luna, Enterprise, or Edu.

[05:11] Grok Bot gives agents one persistent cloud computer and 24/7 work

Grok Bot is xAI's separate agent product, not a mode inside Grok chat. It launched in early beta on August 11 and access was expanded again on August 26. Users create multiple Bots, message them like coworkers, drop them into shared threads, and let one Bot hand work to another.

The core architectural choice is that every Bot a user creates shares one persistent cloud computer, including files, browser state, and logins. Isolation is per user rather than per Bot. That lets a sales Bot research accounts in a logged-in browser, hand the result to an operations Bot that processes invoices from Gmail, and continue while the laptop is closed. Bots can sign into websites that lack APIs or MCP servers, and xAI says they can watch a user complete a workflow once, save it as a routine, accept corrections, and follow up on dropped threads.

Download clients cover macOS on Apple silicon and Intel, Windows 10 and 11 on x64, and iPhone and iPad. The product page does not list an Android Grok Bot client.

Access is included with SuperGrok, SuperGrok Plus, and SuperGrok Heavy subscriptions, with the lowest individual tier at $30 per month. The same product is also bundled with Cursor Pro, Pro+, and Ultra plans starting at $20 per month, and Cursor Teams Standard and Premium. Grok Bot usage is billed separately from standard Grok or Cursor usage. Enterprise access remains waitlist-only.

Security and control features listed by xAI include encryption in transit and at rest, a training opt-out, Auto Review for sensitive actions, and enterprise controls for DLP, certificates, proxies, and network controls.

[06:52] Alibaba Previews Qwen4 Through Qwen3.8-Flash-Next

Alibaba's Qwen Team has released Qwen3.8-Flash-Next, a 125-billion-parameter multimodal Mixture-of-Experts model that previews the upcoming Qwen4 architecture. The headline total is 180 billion parameters, split across three pieces: a 125B backbone, a 51B N-gram embedding table, and a 4B multi-token prediction module. Only 6 billion parameters activate per token, which is where the efficiency story lives.

Four architectural shifts define the preview. A hybrid layer pairs Gated DeltaNet with Qwen Sparse Attention for sequence modeling. Gated Residual connections reshape how gradients flow through the network. The N-gram embedding table gives the model explicit short-range pattern memory, and the Muon optimizer replaces the standard training step. Together these changes cut active compute without shrinking the model's overall reach.

The team reports training cost at roughly one-ninth of Qwen3.7-Plus, a steep drop that the new optimizer and hybrid attention help explain. For self-hosters, the FP8 checkpoint lands at 172.78 GiB, which puts real constraints on consumer hardware and pushes serious deployments toward data-center GPUs.

What this means for builders: the preview gives multimodal teams an early read on Qwen4's direction, especially the hybrid attention approach and the N-gram embedding table. The 172.78 GiB FP8 footprint sets a clear planning floor for storage and memory. Until full Qwen4 ships, treat the benchmark performance as directional rather than definitive.

[08:13] Orchestration overtakes automation as the CX bottleneck, says Tata Communications

Tata Communications is making the case that customer experience work has outgrown its plumbing. Gaurav Anand, who runs the Customer Interaction Suite globally at Tata Communications, says enterprises have spent the last few years bolting conversational AI onto legacy systems that were never built for agentic workloads, and the seams are starting to show.

The result, Anand argues in a VentureBeat column published on August 27, 2026, is that human agents now carry most of the integration burden. They have to stitch together context from disjointed tools just to figure out what an AI system has already told a customer. The bottleneck is no longer access to data, he says, but the absence of a shared enterprise context that ties customer identities, interactions, transactions, policies, journeys, and operational systems into one common understanding.

Traditional CX architecture was designed for linear, human-driven routing, not for orchestrating real-time data flows between autonomous AI agents, data lakes, and human workers. Anand frames the shift as a move from automation to orchestration as the top CX priority. The strategic question, he suggests, is how to coordinate the intelligence already inside the enterprise so the customer never feels the internal silos.

That framing puts orchestration tooling, identity resolution, and context layers at the center of the next CX build cycle, ahead of yet another conversational model upgrade.

[09:37] The real enterprise AI risk hiding between agents

The piece makes one sharp claim: the dangerous part of enterprise AI isn't any single agent going rogue, it's the invisible web of calls between agents that nobody maps or owns.

Real deployments don't ship one agent and watch it run. They ship fleets where every agent calls APIs, calls other agents, and reaches into applications built long before any machine decision-maker existed. A support ticket that used to touch one system might now pass through four agents before a human ever sees it, and every handoff is an approval nobody wrote.

The math is what makes this painful. Adding a tenth agent doesn't add ten connections, it can add dozens, because any agent might call any other agent, and each call can trigger another call somewhere else. Complexity compounds with the number of paths between agents, not with the number of agents themselves, and nobody's job is to draw that graph.

Governance hasn't caught up. Ask a security team which agents can reach which systems and you get silence. Ask which agent triggered which downstream action three hops ago and you get more silence. The instinct is to treat this like a checklist: approve the agent, log the agent, move on. But a checklist checks one moment in time, while complexity runs across a chain. A stack of one-time approvals can't govern a workflow any more than a single vegetable makes a diet.

The practical takeaway for builders: before scaling agent fleets, draw the graph of which agent can reach which system. If nobody on the team can sketch that picture in under five minutes, the deployment is already too opaque to govern.

[11:20] Liquid AI's Pipette Benchmarks Models on the Devices They Actually Run On

Every model card on the internet lists quality numbers measured on server-class hardware with full precision. Those numbers rarely predict how the same model behaves once it is shrunk down and run on a phone or laptop. This week Liquid AI released Pipette, an open-source, reproducible benchmarking suite built to close that gap.

Pipette measures four variables at once: the model, its quantization, the runtime, and the device hardware. Treating those as a single experiment rather than separate questions, it produces numbers that look more like what a developer actually sees when they sideload a model onto real hardware. Liquid AI partnered with Artificial Analysis to serve as an independent methodology validator, which is meant to keep the suite honest about what it is and is not measuring.

For builders shipping on-device features, the practical shift is that model-and-quantization choices can now be backed by measured latency and quality on a specific phone, not extrapolated from a paper. The suite is open source, so teams can add their own device profiles and rerun the matrix on hardware they actually ship to.

The honest caveat is that Pipette measures what it measures; it does not remove the underlying hardware ceilings that constrain on-device AI. But there is now a public, reproducible way to compare candidates on the same playing field, and that is what most on-device projects have been missing.

[12:47] OpenAI's Jalapeño chip posts first inference results

OpenAI published the first performance numbers for Jalapeño, its custom-built chip designed to run AI models in production. Inference, the work of actually generating an answer when a user hits send, is the most expensive part of running a modern AI product, and chips built specifically for it can be faster and cheaper than general-purpose graphics processors. That is the bet behind Jalapeño.

In results published on August 25, OpenAI says the chip delivers industry-leading speed and power efficiency, with higher throughput (more answers per second) and lower latency (less waiting per answer) than comparable options. The company framed the announcement as the first concrete validation of a multi-year effort to design its own silicon rather than depend entirely on third-party accelerators.

The numbers matter because inference, not training, is the recurring bill. A purpose-built chip that handles the same load on less power, or squeezes more responses out of each server, directly lowers the cost of running a chatbot, a coding assistant, or a batched summarization job at scale. For OpenAI that translates into margin, and for anyone building on its APIs it could eventually translate into price moves or new latency tiers.

Two things to watch next: independent benchmarks that confirm or contradict the vendor-supplied numbers, and any signal about whether Jalapeño is limited to internal OpenAI workloads or will eventually serve external traffic through ChatGPT or the API.

[14:14] Google's Tiny Glucose Model Beats Rivals Hundreds of Times Its Size

Google Research and the University of New South Wales Sydney released GlucoFM this week, a foundation model aimed at continuous glucose monitor data. Continuous glucose monitors are the small sensors people with diabetes wear to track their blood sugar around the clock, generating a fresh reading every few minutes.

GlucoFM has just 720,000 parameters, a sliver of the size of most modern AI systems, yet across 14 cohort and task evaluations it averaged 58.8 in precision-recall AUC, beating GluFormer, a 135-million-parameter model built for the same job, and MOMENT, a 385-million-parameter general time-series foundation model. For context, GluFormer is roughly 190 times larger and MOMENT is roughly 535 times larger than GlucoFM.

The trick is how GlucoFM reads the signal. Instead of treating a glucose trace as one long undifferentiated sequence, it splits the data into two streams: a slow physiological stream that captures baseline drift and longer trends, and a transient event stream that catches short-lived spikes from meals, exercise, or medication. Each stream gets its own encoding pathway before the model fuses them back together. The model is pretrained in a self-supervised way, meaning it learns the shape of glucose traces from unlabeled data before any fine-tuning for a specific prediction.

This matters because CGM data is noisy, person-specific, and full of overlapping dynamics. A general time-series model has to learn that separation from scratch with a much bigger parameter budget. GlucoFM bakes the separation into the architecture, which is how a model the size of a small image classifier can win on a clinical-style benchmark.

The caveats are real. GlucoFM is a research prototype with no FDA or equivalent regulatory clearance, so nothing ships to a clinic tomorrow. Google has not announced a public API, open weights, or a device-maker partnership. What GlucoFM does signal is that the bigger-is-better default in medical AI has a credible challenger when the architecture is designed around the biology rather than borrowed from language.

[16:16] Research digest: A Smarter Loop For Teaching Vision Models To Follow Instructions

Training a vision model to follow complex instructions usually means gathering large datasets and hoping they are accurate, varied, and hard enough. The new VISA framework treats that data-creation step as a loop the system improves on itself. Each round, it inspects an image, drops constraints that cannot be verified, and proposes fresh ones drawn from a memory bank. Candidate instructions are checked with executable tools and structured language-model judges, and any failures are diagnosed and fed back so the next round targets exactly the weaknesses the target model still shows.

That feedback does double duty: it sharpens future data and also serves as a reward signal for reinforcement learning, so no separate reward model has to be trained. On the MM-IFEval benchmark, VISA-trained models outperformed strong baselines on instruction following while holding steady on seven general multimodal tests. The practical consequence is cheaper, higher-quality tuning data for anyone building vision assistants that have to juggle several rules at once, like reading a chart and answering in a specific format with a word limit.

[17:22] xAI's Grok 4.6 Lands on Microsoft Foundry

xAI's flagship Grok 4.6 is now available on Microsoft Foundry, Azure's model catalog for enterprise AI deployments. The integration, announced August 26, slots Grok 4.6 alongside other frontier models for direct comparison and deployment through Azure's enterprise infrastructure.

Grok 4.6 ships with a 500,000-token context window and four configurable reasoning effort levels: low, medium, high, and xhigh. xAI describes the model as built for long-running agents and ambitious interactive and visual work, language that signals the company is courting serious agent workloads rather than single-turn chat.

For builders, Foundry offers a single place to evaluate Grok 4.6 against competing frontier models, run workload-specific tests, and deploy managed endpoints under enterprise security and governance controls. xAI specifically calls out coding agents, engineering copilots, research assistants, and enterprise automation as the kinds of systems the model targets, with developers able to start in the Foundry model catalog right now.

[18:17] Research digest: A cheaper way to let AI models think longer

A new technique called Prefix Sliding could make AI models far cheaper to run when they spend a long time "thinking" through hard problems. Today, when a model reasons at length, it keeps every intermediate thought in working memory, so the longer it thinks, the more expensive each question becomes. The researchers found that most of those middle steps stop mattering once the model has moved on, so holding onto them is paying for context that rarely helps.

Their fix is simple in spirit: keep only the original instructions at the front and a sliding window of the most recent few thousand pieces of text, discarding the rest on the fly. That caps memory use no matter how long the chain of thought gets. Without any retraining, applying Prefix Sliding to existing models made them about 3x faster while preserving accuracy, and training with the same policy pushed the ceiling past 100,000 reasoning steps.

For builders shipping agents that need long planning loops, this kind of memory cap matters because inference cost is what keeps ambitious reasoning agents from being economical at scale.

[19:26] Open WebUI Adds Human-in-the-Loop Tool Approval

Open WebUI, the self-hostable chat frontend many local-AI stacks build on, shipped v0.11.1 on August 25. The single documented change is a human-in-the-loop tool approval flow.

Here's how it works. An administrator enables the feature in settings. From then on, any conversation can be switched from the default — where tool calls execute as the model requests them — to a mode where each call pauses and asks the user first. Approval or denial happens by button or keyboard shortcut, one call at a time, and the choice is remembered for the rest of that conversation and for future ones.

The release notes excerpt cuts off mid-feature, so this story stays narrowly on the one change that is documented: the per-call approval gate, its admin-level enable, and its per-conversation toggle.

For self-hosters, this is a real safety lever for any agent workflow. The practical move is to leave the admin switch off for purely conversational chats and turn on per-conversation approval anywhere the model has tools attached, so each call pauses for an explicit allow or deny instead of running unchecked. Watch whether future releases extend the remembered choice beyond a single conversation into workspace-wide defaults, since right now the persistence is local to the chat where the toggle was flipped.

[20:46] Google Splits Its Eighth-Gen TPU Lineup at Hot Chips

At Hot Chips 2026, the annual conference where chip teams unpack their latest silicon for a technical audience, Google discussed its eighth-generation Tensor Processing Unit family. According to a ServeTheHome report published on August 26, the new family is split by workload into two chips: the TPU 8t aimed at training and the TPU 8i aimed at inference.

That division is the structural story of the announcement. One chip is built for teaching models and the other for serving predictions, and Google is presenting them side by side as a matched pair. The company also stands out as one of the only hyperscalers that develops its own training hardware rather than sourcing training silicon from outside vendors — an unusual position in the industry, where most large AI operators buy their training compute from third-party chip makers.

For builders, the practical question is access. Google's TPUs typically reach outside developers through Google Cloud and a small circle of partners, and the technical deep dives published around Hot Chips usually preview what becomes generally available a few months later. The concrete signals to watch for are Google Cloud blog posts and benchmark numbers tied to the new chips, which will reveal whether the eighth generation changes the cost, throughput, or scalability of training or running models on Google's stack.

Chapters

  • 00:00 — Intro: Agent Stack Release Readout: Hermes Agent v2026.8.27, v2026.8.19 / Codex desktop app adds WebMCP, Messages, Linux, and multi-repo review / Grok Bot gives agents one persistent cloud computer and 24/7 work
  • 02:00 — Agent Stack Release Readout: Hermes Agent v2026.8.27, v2026.8.19
  • 03:19 — Codex desktop app adds WebMCP, Messages, Linux, and multi-repo review
  • 05:11 — Grok Bot gives agents one persistent cloud computer and 24/7 work
  • 06:52 — Alibaba Previews Qwen4 Through Qwen3.8-Flash-Next
  • 08:13 — Orchestration overtakes automation as the CX bottleneck, says Tata Communications
  • 09:37 — The real enterprise AI risk hiding between agents
  • 11:20 — Liquid AI's Pipette Benchmarks Models on the Devices They Actually Run On
  • 12:47 — OpenAI's Jalapeño chip posts first inference results
  • 14:14 — Google's Tiny Glucose Model Beats Rivals Hundreds of Times Its Size
  • 16:16 — Research digest: A Smarter Loop For Teaching Vision Models To Follow Instructions
  • 17:22 — xAI's Grok 4.6 Lands on Microsoft Foundry
  • 18:17 — Research digest: A cheaper way to let AI models think longer
  • 19:26 — Open WebUI Adds Human-in-the-Loop Tool Approval
  • 20:46 — Google Splits Its Eighth-Gen TPU Lineup at Hot Chips

Primary Links

Release Coverage Check

  • OpenClaw — Latest stable verified: v2026.6.34, published 2026-08-08T07:22:14Z. Recent episode version tags detected: v2026.7.2-beta.3, v2026.7.2-beta.5, v2026.7.2-beta.7, v2026.8.1-beta.2. No new stable release this cycle.
  • Hermes Agent — Latest stable verified: v2026.8.27, published 2026-08-27T12:06:53Z. Recent episode version tags detected: v2026.8.16, v2026.8.16.2, v2026.8.18, v2026.8.3. Selected missing version(s): v2026.8.27, v2026.8.19.
  • OpenAI Codex — Latest stable verified: rust-v0.150.1, published 2026-08-27T01:56:54Z. Recent episode version tags detected: rust-v0.146.1, rust-v0.147.0, rust-v0.148.0, rust-v0.149.0. No new stable release this cycle.
  • Claude Code CLI — Latest stable verified: 2.1.231, published (date not in registry window). Recent episode version tags detected: 2.1.227, 2.1.228, latest, stable. No new stable release this cycle.
  • Antigravity CLI — Continuous delivery model; no discrete release tags verified this cycle (latest build as of 2026-08-27). Recent episode version tags detected: none on record.

Harness Version Reference

  • OpenClaw — v2026.6.34 (stable) / v2026.8.1-beta.3 (prerelease)
  • Hermes Agent — v2026.8.27
  • OpenAI Codex — rust-v0.150.1
  • Claude Code CLI — 2.1.231
  • Antigravity CLI — Continuous delivery (no tagged release verified this cycle)

🎙 Never miss an episode — subscribe now

SpotifyAppleiHeartYouTube MusicAmazonRSS
🎙 Subscribe to AgentStack Daily