
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 EpisodeAgentStack 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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
- Hermes Agent v2026.8.27 release: https://github.com/NousResearch/hermes-agent/releases/tag/v2026.8.27
- Hermes Agent v2026.8.19 release: https://github.com/NousResearch/hermes-agent/releases/tag/v2026.8.19
- Codex desktop app adds WebMCP, Messages, Linux, and multi-repo review: https://learn.chatgpt.com/docs/changelog?type=codex-app
- Grok Bot gives agents one persistent cloud computer and 24/7 work: https://x.ai/news/introducing-grok-bot
- Alibaba’s Qwen Team Releases Qwen3.8-Flash-Next: A 125B Multimodal MoE: https://www.marktechpost.com/2026/08/26/alibabas-qwen-team-releases-qwen3-8-flash-next-a-125b-multimodal-moe-with-6b-active-parameters-previewing-the-qwen4-architecture/
- Orchestration is the new challenge for CX in the age of AI agents: https://venturebeat.com/orchestration/orchestration-is-the-new-challenge-for-cx-in-the-age-of-ai-agents
- Enterprise AI's real risk isn't autonomous agents. It's the complexity: https://venturebeat.com/ai/enterprise-ais-real-risk-isnt-autonomous-agents-its-the-complexity-between-them
- Liquid AI Open-Sources Pipette: A Reproducible Benchmarking Suite That: https://www.marktechpost.com/2026/08/25/liquid-ai-open-sources-pipette-a-reproducible-benchmarking-suite-that-measures-on-device-models-quantization-runtime-and-hardware-together/
- Jalapeño’s first results show industry-leading speed and efficiency in: https://openai.com/index/jalapeno-first-results
- Google Research Introduces GlucoFM: A 0.72M-Parameter Dual-Stream Foun: https://www.marktechpost.com/2026/08/26/google-research-introduces-glucofm-a-0-72m-parameter-dual-stream-foundation-model-for-continuous-glucose-monitoring/
- VISA: Agentic Self-Evolving Data Synthesis for Multimodal Instruction : https://arxiv.org/abs/2608.26013
- Grok 4.6 on Microsoft Foundry: https://x.ai/news/grok-4-6-microsoft-foundry
- Prefix Sliding for efficient test-time scaling: https://arxiv.org/abs/2608.26070
- open-webui/open-webui ships v0.11.1: https://github.com/open-webui/open-webui/releases/tag/v0.11.1
- Google’s TPUv8s for Training and Inference at Hot Chips 2026: https://www.servethehome.com/googles-tpuv8s-for-training-and-inference-at-hot-chips-2026/
- HKUDS/nanobot repo: https://github.com/HKUDS/nanobot
- DeusData/codebase-memory-mcp repo: https://github.com/DeusData/codebase-memory-mcp
- PrefectHQ/fastmcp repo: https://github.com/PrefectHQ/fastmcp
- Radar makes podcasts searchable — and usable by AI agents: https://techcrunch.com/2026/08/26/radar-makes-podcasts-searchable-and-usable-by-ai-agents/
- 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
- Perplexity Ships Portable Computer on NVIDIA DGX Spark: Local Harness,: 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/
- zai-org/GLM-5.3-Flash: https://huggingface.co/zai-org/GLM-5.3-Flash
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)
AgentStack Daily EP107 — Codex Desktop Adds WebMCP, Messages, Linux, and Multi-Repo Review
Nova I'm NOVA.
Alloy I'm ALLOY, and this is AgentStack Daily...
Nova OpenAI just turned the Codex desktop app into a broader agent workspace. It can discover website tools through WebMCP, review changes across several repositories together, work natively on Linux, and ask before sending an Apple Message. That’s coding, browsing, collaboration, and communication moving into one surface.
Alloy And cloud agents aren’t waiting politely in another tab. Grok Bot gives multiple agents a shared persistent computer, complete with files, browser state, and logins, so they can keep handling research, invoices, and follow-ups after the laptop closes. That’s exciting—and a shared logged-in machine deserves serious respect.
Nova Hermes shipped releases 8.27 and 8.19. The newer one rolls up roughly five hundred twenty-five merged pull requests, adds a separate browser window, managed remote updates, more than fifty verified remote tool servers, and tighter controls around installs, secrets, and long-running work.
Alloy Today: the Qwen4 architectural preview, OpenAI’s first Jalapeño inference-chip results, a tiny glucose model beating systems hundreds of times larger, and two Google chips dividing training from inference. You’ll hear what people can build with them—and where autonomy is getting ahead of governance.
[PAUSE]
[02:00] Agent Stack Release Readout: Hermes Agent 8.27, 8.19
Nova Hermes Agent release 8.27 landed August twenty-seventh, superseding the 8.19 baseline and consolidating roughly five hundred twenty-five merged pull requests into one stable release for Docker images, hosted deployments, and fresh installations. The most visible change pulls the desktop Browser out of the chat panel and gives it an independent operating-system window. A browsing session can remain visible, be docked, or close without treating the browser as another piece of conversation output. Remote machines gain managed updating through SSH, plus a fleet-profile rail for organizing them. Those updates pause the gateway through its control socket instead of terminating it while work is active. Local browsing can use the person’s default Chromium profile through a consent gate, which means a site that already has a valid login can be opened without starting a separate authentication session. On Windows, closing that browser path requires approval. Hermes also expanded its remote Model Context Protocol catalog beyond fifty live-verified, vendor-hosted servers. Model Context Protocol is the common interface agents use to reach external tools and data. The catalog now includes services from Cloudflare, Grafana Cloud, Better Stack, and Railway, reducing the need for a local connector between Hermes and those services.
Alloy That’s a dense release, but the quieter runtime changes may matter more after the first day. Web search and extraction now cache results for a defined lifetime, while tool search can issue several queries and match word variants, so “run” and “running” don’t behave like unrelated concepts. Mac users can opt into operating-system keychain encryption for stored secrets without accepting repeated prompts every time Hermes starts. Lean-tail compression is now enabled by default to shorten responses while preserving useful content. Image-based and package-managed installations refuse unsafe in-place updates, Slack gains controls for link previews, Docker containers can share identities, and terminal environments can come from replaceable backends. The model pickers add GLM five point three Flash, MiniMax M three free, and MiniMax H three Max video. Release 8.19 supplied the earlier foundation: a keyless web tier with free rotation across five vendors and failover between them, plus a fuzzy model picker and a control-P command palette. I like the separate browser window; I like update handling that doesn’t kill a task even more. The breaking plugin-manifest change does mean integrations built against the older schema need adjustment, and legacy command flags are being retired. Hosted tenants receive 8.27 in waves, while self-hosted installations have to rerun the installer to receive the new manifest structure.
[PAUSE]
[03:19] Codex desktop app adds WebMCP, Messages, Linux, and multi-repo review
Alloy WebMCP sounds like another protocol label. What did OpenAI actually put in someone’s hands?
Nova The Codex desktop app can now use Site Tools that a website exposes through WebMCP, allowing ChatGPT Work or Codex to interact with supported site functions through a defined tool interface. That arrived August twenty-fifth and requires the latest desktop app plus a GPT-five point six Sol or Terra subscription; it isn’t available on Luna, Enterprise, or Edu. The extension also moved beyond Chrome to Edge, Brave, Opera, and Vivaldi. All five support tab mentions and browser control, although Opera lacks side chat. Earlier updates filled out the workspace around that browser. Multi-folder projects now have one combined review view for changes across repositories. That’s a meaningful improvement when an application, shared library, and deployment configuration live separately but change together. Generated images gained Focused and Canvas views for comments and refinement. Browser history, address-bar search, selected Chrome text, YouTube questions, and right-click Ask ChatGPT all became usable context, with browsing-history access remaining optional.
Alloy And Linux is no longer watching through the window. The August eleventh preview supports Ubuntu, Debian, and Fedora across x64 and ARM64, using the native package formats those distributions expect. The app can import instructions, settings, skills, plugins, projects, and recent work from the terminal-based AI coding agent Claude Code, Claude Cowork, and Cursor, with optional updating of imported material. On macOS, an Apple Messages plugin can send from ChatGPT Work or Codex only after approval. Shared snapshots offer a read-only view of local Codex threads, though OpenAI warns its secret-pattern redactor may miss sensitive details. Unified pinned threads also carry across desktop and iOS, while same-workspace Site editing can preserve shared context as a page changes. So yes, the app is becoming a cross-platform agent workspace—but a share button beside local development context still deserves a careful second look.
[PAUSE]
[05:11] Grok Bot gives agents one persistent cloud computer and 24/7 work
Nova Grok Bot is a separate xAI agent product, not a button inside ordinary Grok chat. It entered early beta August eleventh and expanded access again August twenty-sixth. A person can create several Bots, message them like coworkers, put them into shared threads, and hand work from one to another. All Bots owned by one user share a persistent cloud computer, including files, browser state, and authenticated sessions. Isolation happens between users, not between a user’s Bots. A research Bot could work in a signed-in browser, pass account information to an operations Bot, and let it process Gmail material while the user’s laptop is closed. Websites don’t need an API or Model Context Protocol server because the Bot can operate their browser interfaces.
Alloy That’s wild—and the shared machine is both the feature and the reason to pause. xAI says Bots can watch someone perform a workflow once, save it as a routine, absorb corrections, and return to abandoned threads. Clients cover Macs, x64 Windows ten and eleven machines, plus iPhone and iPad; xAI doesn’t list Android. The lowest entry point is Cursor Pro at twenty dollars monthly; SuperGrok starts at thirty. Higher Cursor, SuperGrok, and team plans also qualify, and Bot usage is separate from ordinary Grok or Cursor allowances.
Nova xAI lists encryption in transit and at rest, a training opt-out, automatic review for sensitive actions, and enterprise controls covering data-loss prevention, certificates, proxies, and networks. Enterprise access remains waitlist-only. Those controls matter because a continuously logged-in agent can encounter much more than its named task.
Alloy “Always running” is better only when the agent remembers the right state, respects boundaries, and leaves a comprehensible trail. A shared cloud computer makes collaboration between Bots fluid but concentrates their reach. Grok Bot asks people to treat agents as ongoing occupants of a computer, not disposable chat sessions. That’s a much bigger relationship.
[PAUSE]
[06:52] Alibaba Previews Qwen4 Through Qwen3.8-Flash-Next
Alloy Alibaba previewed Qwen4 without calling the checkpoint Qwen4. So what exactly is Qwen three point eight Flash Next?
Nova It’s a multimodal Mixture-of-Experts model from the Qwen Team and an architectural preview of the next generation. Mixture-of-Experts means only part of the network works on each piece of input. The model has a one-hundred-twenty-five-billion-parameter backbone, a fifty-one-billion-parameter N-gram embedding table, and a four-billion-parameter module that predicts several tokens ahead. Alibaba gives the combined total as one hundred eighty billion parameters, but only six billion activate per token. That small active slice drives its efficiency claim. The checkpoint handles text and visual material, while its million-token context capacity targets long documents, codebases, and extended agent work.
Alloy The N-gram table is the unusual piece. It gives the model dedicated memory for short recurring patterns rather than making the main network rediscover every local relationship. Alibaba also combines Gated DeltaNet with sparse attention, pairing efficient sequence tracking with selective long-range connections. Gated residual paths change how information flows during training, and the Muon optimizer replaces the conventional update step. Alibaba says training cost fell to about one-ninth of Qwen three point seven Plus. That number comes from Alibaba, so it’s a claim until outside work reproduces it.
Nova And “efficient” doesn’t mean casual-laptop small. The FP8 checkpoint occupies roughly one hundred seventy-three gibibytes. FP8 stores model weights with eight-bit numbers to reduce memory, yet this still points toward data-center graphics processors for serious self-hosting. Six billion active parameters could make serving cheaper than the total size suggests, but the memory footprint remains substantial. This is a runnable preview of Qwen4’s direction, not proof of the finished family’s performance.
[PAUSE]
[08:13] Orchestration overtakes automation as the CX bottleneck, says Tata Communications
Nova Tata Communications says adding more conversational AI isn’t fixing customer service when the systems behind it remain disconnected. Gaurav Anand, who leads the company’s Customer Interaction Suite globally, argues that enterprises attached AI to legacy customer-experience software built for linear, human-directed routing. Human representatives now end up reconstructing what an AI already said, which systems it touched, and what the customer was trying to accomplish. A clever assistant becomes another silo if it sees the support conversation but not the transaction, policy, identity, or journey behind it. Anand says the constraint has shifted from obtaining data to creating shared enterprise context: one working understanding connecting identities, interactions, transactions, policies, operational systems, and human staff. Autonomous agents make that gap harder to hide because they exchange information in real time and may act before a person assembles the missing context.
Alloy That rings true. His conclusion is that orchestration now outranks another round of isolated automation. In plain English, companies need their existing intelligence to coordinate across systems so customers don’t experience the seams. That puts identity resolution, context layers, and agent coordination ahead of simply replacing a chatbot model. It also changes what good service looks like. A customer shouldn’t have to repeat a failed delivery, an earlier promise, and the account history because three agents each inherited a different fragment. Anand is a vendor executive, so this isn’t neutral market measurement. Still, he identifies a recognizable failure: the customer hears one company while its software behaves like six departments meeting for the first time. Faster answers won’t repair that fragmentation; they may only expose it sooner. And once an agent can issue a refund, change an order, or promise a delivery date, disconnected context stops being merely annoying. It becomes an operational liability with a customer attached.
[PAUSE]
[09:37] The real enterprise AI risk hiding between agents
Alloy One agent gets a security review. Ten agents start calling one another. How quickly does that become a different problem?
Nova Very quickly, because possible relationships grow faster than the agent count. A support request might pass through a classifier, customer-record agent, policy agent, and fulfillment agent before a person sees it. Each transfer carries authority, context, and implied approval. Another agent may connect to several existing agents and systems, creating many paths rather than one new link. Reviewing agents separately can miss what the fleet does together. A low-privilege agent may call one with broader access, which triggers a third system. Nobody deliberately granted the first agent the final capability, yet the chain produced it.
Alloy Later, investigators may see isolated logs but struggle to reconstruct why an action occurred three hops downstream. Governance has to account for reachable paths, not only named components: which agents can contact which systems, what identity each call carries, and how an upstream request becomes a downstream action. One-time approval records age badly as deployments, tools, and permissions change. If ownership stops at each agent’s boundary, the space between them becomes unowned infrastructure.
Nova Familiar controls can appear healthy separately. Each agent may have an owner, each tool may log requests, and each application may enforce permissions. The combined chain can still produce an unintended outcome because no component sees the entire path. Duplicate records can diverge as agents pass summaries instead of original context, leaving downstream actions based on compressed or outdated accounts.
[PAUSE]
[11:20] Liquid AI's Pipette Benchmarks Models on the Devices They Actually Run On
Nova Liquid AI released Pipette, an open-source benchmarking suite for measuring models on the phones, laptops, and other devices where they’ll actually run. Model cards often report quality under server-class conditions and generous numeric precision. Once a model is compressed, placed behind a mobile runtime, and constrained by a real processor and memory system, those headline numbers may predict very little.
Alloy Pipette treats the model, quantization, runtime, and device as one combined experiment. Quantization means representing a model’s numbers with fewer bits, cutting memory and often increasing speed at the possible cost of quality. That trade changes across chips and software. A model that looks best at full precision on a server may lose to a smaller competitor after both are compressed for one phone.
Nova Liquid AI partnered with Artificial Analysis as an independent methodology validator. Pipette can report quality and latency for a defined model configuration on specific hardware, and teams can add device profiles because the suite is reproducible and open source. That’s much closer to the decision behind an offline writing assistant, camera feature, or local voice interface: not “Which model leads globally?” but “Which exact package responds fast enough and stays accurate on the device people own?”
Honestly, I’m enthusiastic about that shift because on-device AI has suffered from benchmark teleportation—numbers measured in one environment somehow materialize in marketing for another. Pipette can’t lift a phone’s thermal, memory, or battery ceilings, and its results cover only the configurations measured. But it supplies a shared language for the compromise. Sustained use matters too: a model can look fast for one burst and slow down as a device heats up. Once the model and deployment stack become one observable product, those physical constraints stop hiding behind an abstract leaderboard. That won’t make device choices simple; at least it makes them real. Teams can also compare sustained runs, not only a single cool-device burst.
[PAUSE]
[12:47] OpenAI's Jalapeño chip posts first inference results
Alloy OpenAI says Jalapeño delivers industry-leading inference speed and power efficiency. How much can we conclude from the first numbers?
Nova We can conclude that OpenAI’s custom inference chip has reached the point of producing disclosed performance results. Inference is the computation used when a trained model generates an answer. It’s the recurring expense behind every chatbot reply, code completion, image interpretation, and automated summary. OpenAI says Jalapeño produces higher throughput—more answers per second—and lower latency—less waiting for each answer—than comparable options. Those results were published August twenty-fifth as the first concrete validation of a multi-year effort to design internal silicon.
Alloy But those are OpenAI’s measurements, so I don’t buy “industry-leading” as settled until independent benchmarks define the workloads and reproduce the comparison. Chip results can change dramatically with model size, numeric format, batching, memory movement, and how much traffic arrives at once. A favorable internal workload doesn’t automatically predict every external application.
Nova What is already clear is why OpenAI wants the chip. Training gets the giant capital-spending headlines, but inference repeats every time somebody uses the product. More responses per server or fewer watts per response can improve margins at enormous scale. It may eventually affect pricing, response speed, or the size of models OpenAI can serve economically. Owning more of the serving stack also gives OpenAI leverage over capacity planning and outside accelerator road maps. The next useful disclosures are whether Jalapeño remains internal, whether ChatGPT or API traffic runs on it, and how it performs under independently comparable conditions. First silicon results are real progress. They’re not yet a public victory lap.
[PAUSE]
[14:14] Google's Tiny Glucose Model Beats Rivals Hundreds of Times Its Size
Nova Google Research and the University of New South Wales Sydney built GlucoFM, a foundation model for continuous glucose-monitor data, with only seven hundred twenty thousand parameters. Across fourteen cohort and task evaluations, it averaged fifty-eight point eight on precision-recall area under the curve, a score useful when important events are less common than ordinary readings. It beat GluFormer at one hundred thirty-five million parameters and MOMENT at three hundred eighty-five million. Those competitors are roughly one hundred ninety and five hundred thirty-five times larger. That’s the kind of tiny-model result that earns attention. Continuous glucose monitors produce a reading every few minutes, but the trace mixes slow biological drift with short spikes caused by meals, exercise, medication, stress, and other events.
Alloy GlucoFM doesn’t force one general sequence model to untangle everything through scale. It separates the trace into a slow physiological stream and a transient-event stream, encodes them through distinct pathways, and then combines them. It learns first from unlabeled glucose traces through self-supervision, absorbing recurring structures before adaptation to a particular prediction. That matters because medical labels are expensive, cohorts differ, and glucose data is noisy and highly individual. Okay, the size comparison is startling, but I’d resist turning one benchmark win into a clinical revolution. GlucoFM is a research prototype with no announced regulatory clearance, public programming interface, open weights, or device partnership. Nothing here authorizes a medical decision. What it challenges is the assumption that a biomedical foundation model must inherit language-model scale. When the design separates biological processes the way the data behaves, hundreds of millions of generic parameters may be less useful than a small model shaped around the physiology. A model this compact could eventually make continuous analysis easier to place near the sensor or inside constrained health hardware, but the published evaluation establishes research performance, not clinical deployment.
[PAUSE]
[16:16] Research digest: A Smarter Loop For Teaching Vision Models To Follow Instructions
Nova VISA is a framework that improves the instructions used to train vision models. It examines an image, removes requirements that can’t be verified, proposes new constraints from stored examples, and checks candidate tasks using executable tools plus structured judgments from a language model.
Alloy So it doesn’t keep producing more of the same synthetic material?
Nova Right. When the target vision model fails, the framework diagnoses the weakness and designs later training material around it. That feedback also becomes a reinforcement-learning reward, avoiding a separately trained reward model. On MM-IFEval, a benchmark for multimodal instruction following, VISA-trained models beat strong baselines while preserving results across seven broader multimodal evaluations.
Alloy That’s the useful result: the data changes in response to what the model still misunderstands. It can sharpen assistants asked to inspect an image, obey several constraints, and return a precise format without trading away broader visual ability. Generated instructions still aren’t automatically trustworthy, but failure diagnosis becomes both curriculum and training signal.
[PAUSE]
[17:22] xAI's Grok 4.6 Lands on Microsoft Foundry
Alloy Grok four point six is now in Microsoft Foundry, Azure’s catalog for evaluating and deploying managed AI models. That puts xAI’s flagship inside the same enterprise purchasing and infrastructure surface as competing frontier systems. It has a five-hundred-thousand-token context window and four reasoning-effort settings: low, medium, high, and extra high.
Nova xAI positions it for long-running agents, coding systems, engineering copilots, research assistants, enterprise automation, and interactive visual work. The context window can hold large bodies of code or documents, but capacity alone doesn’t guarantee useful attention across every token. Foundry makes comparisons easier because organizations can place Grok beside other catalog models within Azure instead of building an entirely separate deployment path.
Alloy And that distribution may matter almost as much as another benchmark chart. Managed endpoints fit the enterprise controls, purchasing relationships, and governance surfaces customers already use in Azure. Grok Bot is xAI’s persistent-computer bet; Grok four point six on Foundry is the model-supply bet. One gives agents an ongoing machine, while the other gives companies a managed model endpoint. Those are very different trust decisions even though the Grok name sits on both.
Those options can be separated in practice. A company may want Grok’s model without giving a persistent Bot a logged-in computer, or it may want both at different trust levels. Foundry lowers procurement friction, not uncertainty. Quality, latency, data handling, and economics still depend on the workload. But xAI has gained a conventional route into organizations already standardized around Azure identity, billing, monitoring, and deployment. That can turn a model from an interesting outside option into something an existing team can actually purchase and operate without creating a separate infrastructure island. That distinction is central when evaluating xAI’s desktop agent against its hosted model.
[PAUSE]
[18:17] Research digest: A cheaper way to let AI models think longer
Nova Prefix Sliding reduces the memory cost of long model reasoning by retaining the original instruction plus only a moving window of recent text.
Alloy So the model keeps thinking, but it doesn’t drag every earlier thought behind it?
Nova Exactly. Older intermediate steps are discarded as the model proceeds, placing a ceiling on working memory even when the reasoning chain keeps growing. Researchers report roughly a threefold speed increase without retraining while preserving accuracy. Models trained with the same policy extended beyond one hundred thousand reasoning steps.
Alloy That doesn’t prove every discarded thought was useless. It suggests much of the middle history stops contributing once the model advances. Long-running agents currently pay repeatedly to carry expanding context through every step, so a stable recent window could reduce memory pressure. The tradeoff is selective forgetting: an early discovery may still matter after it leaves the window.
[PAUSE]
[19:26] Open WebUI Adds Human-in-the-Loop Tool Approval
Alloy Open WebUI release .11 adds a human approval gate for tool calls. Because it’s a self-hosted interface used in local-AI systems, attached tools can turn a conversation into action. An administrator enables the capability, and a conversation can switch from automatic execution to a mode where every requested tool call waits for an allow or deny decision. The person responds by button or keyboard shortcut, one call at a time.
Nova Finally, a local interface is treating the jump from words to actions as a visible event. The choice is remembered when someone returns to the conversation. The documented capability is deliberately narrow: administrator-level enablement, a per-conversation mode, and per-call decisions. It doesn’t claim to be a workspace-wide policy engine. Narrow is fine. A local model that can search files, contact services, or alter data crosses a meaningful boundary when it invokes a tool. Open WebUI now places a decision at that boundary without removing tools entirely. The same conversation can remain useful for analysis while a sensitive action waits for a person. That separation is especially valuable when a model proposes several calls and only one deserves permission. I wouldn’t confuse repeated clicks with complete governance—a persuasive harmful request can still be approved, and approval says nothing about whether the underlying tool is safely designed. But explicit consent makes silent execution less likely and gives human intent a clear opportunity to interrupt the action before it reaches another system.
[PAUSE]
[20:46] Google Splits Its Eighth-Gen TPU Lineup at Hot Chips
Nova Google presented its eighth-generation Tensor Processing Unit family at Hot Chips as two workload-specific chips: TPU 8t for training and TPU 8i for inference. Training is the expensive process of teaching a model from data; inference is the repeated work of using that model to produce results. Google is designing separate silicon around those different demands instead of presenting one chip as the universal answer.
Alloy That split echoes Jalapeño. Once inference becomes a huge recurring workload, optimizing only for giant training runs leaves money and power efficiency on the table. Training favors enormous parallel computation and communication across accelerators. Inference also has to handle response time, serving volume, memory access, and traffic that rises and falls unpredictably. A matched family lets Google tune each chip while keeping related software, networking, and cloud infrastructure around them. Google’s unusual advantage is that it can shape the model software, compiler, data-center network, accelerator, and cloud service together rather than buying every layer from separate vendors.
Nova I’m interested, but the Hot Chips disclosure establishes the division of labor more clearly than it establishes customer economics. Public conclusions still need Google Cloud availability, workload-specific benchmarks, and pricing. Google’s TPUs generally reach outside developers through its cloud and selected partners, and conference presentations often arrive before broad availability. If 8t lowers the cost of large training clusters while 8i improves serving throughput or latency, Google can turn hardware specialization into visible cloud advantages. It could also allocate expensive training capacity separately from the steadier fleet needed to answer production requests. For now, the firm fact is that Google no longer wants one eighth-generation TPU to represent both jobs. The competitive question is whether customers can see those gains in actual services—and buy them at a price that matters.
[PAUSE]
[22:08] GitHub Project Radar
Nova Nanobot arrives with forty-seven thousand four hundred sixty-six stars on its first tracked appearance. It’s an ultra-lightweight, self-hosted Python agent framework combining a web interface, tools, memory, Model Context Protocol support, multi-agent workflows, automation, and chat integrations. Release .3 landed July twenty-fifth, and the repository was active again August twenty-seventh. Codebase Memory MCP is close behind at forty thousand eight hundred seventy stars, up six thousand one hundred twenty-three in thirty days—a seventeen-point-six-percent jump. It turns repositories into persistent knowledge graphs and claims sub-millisecond queries across one hundred fifty-eight languages from a dependency-free static binary.
Alloy Those two fit together unusually well: Nanobot can coordinate personal agents, while Codebase Memory gives coding agents a durable repository map instead of making them repeatedly read the same files. FastMCP supplies the Python construction layer for custom Model Context Protocol servers. It has twenty-seven thousand four hundred six stars, gained five hundred ninety-five over thirty days, and shipped release three point four in August. Codebase Memory has the strongest traction event with release .10 and that seventeen-point-six-percent growth. FastMCP’s increase is smaller, but its role is foundational: it helps developers expose their own services as tools the other agent systems can call.
[PAUSE]
[23:34] Model Discovery Check
Nova Model progress today landed in architecture, serving, and domain adaptation rather than a new general-purpose flagship. Qwen three point eight Flash pairs multimodal reasoning with a million-token context window, while GLM five point three Flash offers native multimodality, efficient coding, and roughly one-point-three-million tokens of context through hosted access.
[PAUSE]
[24:12] Local LLM Spotlight
Alloy The selected local release is zai-org/GLM-5.3-Flash, spoken as Z.ai’s GLM five point three Flash. It’s trending on Hugging Face with one thousand two hundred forty-eight likes, thirty-four recorded downloads, and an MIT license. Its published tags cover text generation, conversation, and image-to-text work across English and Chinese, with weights packaged in Safetensors for common transformer runtimes.
Nova That combination is compelling: long context, multimodal input, and downloadable weights aimed at coding and extended agent tasks without forcing every request through a closed application. “Open” doesn’t erase deployment cost; the weight format, context behavior, benchmark conditions, and hardware requirements determine where it can realistically run. But direct access to the weights gives organizations control over data placement, serving, and modification that an API-only listing can’t provide.
[PAUSE]
[25:04] Extra Research Candidates
Nova Radar makes podcasts searchable—and usable by AI agents. Particle’s platform has transcribed and indexed more than one hundred thirty thousand podcasts, exposing their conversations through search, an API, and Model Context Protocol. EDB, meanwhile, argues that governance has to live in the data layer because executable policy can control rapid agent access more reliably than prompt-level requests.
Alloy Those developments collide neatly: agents can query spoken knowledge as structured data, so access policy has to travel with that data. Perplexity’s Portable Computer covers execution by combining local models, a harness, connectors, and an operating-system-enforced sandbox on NVIDIA DGX Spark. Local steps carry no per-token charge, while the sandbox provides a defined boundary around what those steps can touch.
[PAUSE]
[25:48] Closing
Nova For the sources, specifications, project pages, and supporting details behind everything we covered, look at the show notes at Toby On Fitness Tech dot com.
Alloy Thanks for listening to AgentStack Daily.
Nova We'll be back soon.