← Back to search
Episode 122: OpenAI Ships GPT-6, Gemini Goes Agentic, and EmbeddingGemma 2 Sees Everything
AgentStack Daily · 2026-10-13 · 32 min
Show full episode description
OpenAI ships GPT-6 globally with an Intelligent UI. Google turns Gemini into an objective-taking workplace agent, and DeepMind's EmbeddingGemma 2 puts four... Show notes: https://tobyonfitnesstech.com/podcasts/episode-122/
✨ Episode Outline — click any point to jump to it in the episode
Problem solved
Rounds up a week of agent-platform releases — GPT-6,
Gemini's workplace agent,
Hermes Agent 0.21.6, sandboxed Copilot commands, and new embedding models — and weighs what each actually changes for builders.
Benefits
- Hermes 0.21.6 isolates voice, plugins, local inference and review into separate observable surfaces
- Gemini workplace agent gets its own identity, email and audit trail for attributable work
- GitHub Copilot sandbox enforces one policy across Windows, macOS and Linux via MXC
- EmbeddingGemma 2 puts text, code, image, video and audio in one 768-dim space
- Copilot CLI auto-discovers local Ollama models without restarting the agent
Use cases
- Hand Gemini an objective spanning Workspace, Slack, Jira, BigQuery and Snowflake; it plans, loads skills and delegates subagents
- Run semantic search across photos, meetings and code on-device with EmbeddingGemma 2, shrinking vectors to 256 dims at ~1/3 storage
- Enterprise admins require Copilot's sandbox via managed settings so agents can't reach credentials or forbidden hosts
- Hermes streams live voice transcription in CLI/TUI/desktop and routes voice to a dedicated no-reasoning model
- Self-host Perplexity PPLX Embed V2 (600M edge or 9B index-quality) under MIT license
KPIs / results
- Hermes 0.21.6: ~2,100 PRs, 8,867 commits, ~772K lines added, 225K removed, 3,000+ issues closed
- Gemini ~1B monthly users; ~90% of Fortune 100 use Gemini Enterprise
- StepFun Step 5: 600B total / 27B active params, 1M-token context
- PPLX Embed V2 9B: 92.4% on MTEB but 61.2% on markdown subset; EmbeddingGemma 2 at 256 dims drops 61.36→60.41
Tools / build
- Hermes Agent 0.21.6
- Gemini Enterprise workplace agent
- GitHub Copilot CLI sandbox (MXC)
- EmbeddingGemma 2
- PPLX Embed V2
I'm Nova. I'm Alloy, and this is AgentStack Daily. OpenAI has started rolling out GPT-6 worldwide, and ChatGPT's new intelligent UI can place interactive experiences directly inside an answer. Google is making an even bigger organizational bet. Gemini can accept an objective, plan the work, load skills, consult company systems, and delegate parts of the job. It even gets its own workplace identity, complete with email, context, and an attributable audit trail. Okay, that's a meaningful change in what people can build. A company can hand an agent a research objective-spanning workspace, Slack, Jira, and Snowflake. A phone can search text, images, audio, and video through one local embedding space. And a 17-megabyte speech model can turn a voice command into a structured tool call without sending the raw transcript to a cloud service. Today, GPT-6, Gemini's workplace agent, EmbeddingGemma 2, Self-Correcting Agents from NVIDIA, Sandboxed Copilot Commands, Formal Mathematical Proofs, and a Serving Engine that switches between models while it writes. Hermes Agent Point 21.6 landed October 8 as a massive consolidation release from Nouse Research. Roughly 2,100 pull requests since Point 21.5 flowed into the first stable Docker and Hermes Cloud tag produced by a new release pipeline. The underlying window covers 8,867 non-merge commits, more than 8,000 changed files, roughly 772,000 lines added, 225,000 removed, and just over 3,000 closed issues. Container and cloud users receive this release first, desktop, termux, and Microsoft Store packages move with a later bundled release. The concrete additions span voice, local inference, plugins, review, and safety. Live transcription can stream while someone speaks in the command-line interface, terminal interface, or desktop app. Spoken conversations can route to a dedicated voice model with reasoning disabled by default, separating quick voice interaction from heavier reasoning calls. Third-party plugins can run inside an isolated host for each profile, keeping a faulty plugin away from the main Hermes configuration. Local models appear directly in the model list, backed by Lama.cpp Cuda support on Linux for both X64 and ARM64 systems. That's a lot more than a ceremonial patch, although the complete curated account is being saved for .22. Hermes now exposes more of the agent state without making every view noisy. Status can open with a compact summary and expand when needed. The review pane can isolate uncommitted work, the current branch, or only the last turn. Provider rate limits explain both the reason and when access resumes. Scheduled jobs warn when their storage becomes unrightable, while KeepAwake follows the active turn instead of blindly preventing sleep. Two approval prompts address particularly sneaky hazards, uploading credentials and executing commands containing invisible Unicode characters. The desktop model picker keeps favorites at the top, which sounds small until the catalog becomes crowded. Discord setup now validates the bot token and produces the invite link, layered language packs can span the core product, desktop app, and terminal interface, and the release includes a unified Kanban workflow. The catalogs also add GPT-6.1 Sol, Claude Sonnet 5.5, and Haiku 5.5. I keep coming back to the isolation work. Voice traffic, plugins, local inference, and review scope are becoming separate, observable surfaces instead of one tangled agent process. That won't make 2100 merged changes easy to absorb, but it makes the resulting system easier to understand when something behaves badly. StepFund's StepFund's Step 5 preview is now listed on OpenRouter as its flagship model for agentic work. It uses a sparse mixture of experts' design. 600 billion parameters exist across the model, but 27 billion activate for a given token. In ordinary terms, the model can draw from enormous total capacity without running every parameter during every step. The listing gives it a 1 million token context window and highlights software engineering and professional agent tasks. Access comes through OpenRouter's API, placing the preview behind the same request Surface developers may already use for other providers. A million tokens sounds irresistible, but does that automatically make it a better coding agent? No, and this is where the giant number can outrun the evidence. Context capacity doesn't prove that an agent can navigate a repository, choose the right tools, repair a bad edit, or remain coherent throughout a long task. The listing establishes the architecture, access route, intended workload, and a model designed around agentic work. It doesn't guarantee performance in somebody's real code base. Still, 27 billion active parameters out of 600 billion total is an aggressive balance between breadth and inference cost. A million token window could hold a large body of source code, documentation, issue history, and tool output in one session. But the model still has to identify what matters. The preview label matters because behavior can shift as StepFun develops it. What makes the listing notable is the combination of a major provider model, unusually long context, and an explicit focus on sustained software and professional work rather than ordinary chat. Google's phrase here is unusually precise, objectives, not just instructions. Gemini's workplace agent can receive a goal, plan a multi-step job, load custom skills, and connect to internal systems. It's launching first for Gemini Enterprise customers, where identity, permissions, spending, and auditability become much harder than making a polished demonstration. And Google already has serious distribution. Sundar Pichai said Gemini has roughly 1 billion monthly users and that about 90% of the Fortune 100 use Gemini Enterprise. The agent can work across Google Workspace, Microsoft 365, Slack, Jira, Confluence, GIT, BigQuery, Databricks, Postgres, and Snowflake. Files, folders, and project packs can travel with a task. Tools connect through the model context protocol, a common way for an AI system to call external services. Google selects models automatically, but users can override that choice. Anthropics Claude is the first outside option, with private and open models promised later. The workplace identity may matter even more than the model picker. The agent gets its own workspace account, email, context, and audit trail. It can read organizational relationships, calendars, time zones, and approval chains. People can reach it by tagging it, emailing it, sharing material, or adding it to a group conversation. A task inbox exposes progress, loaded skills, and delegated subagents. Work performed by the agent can therefore be attributed to a distinct participant instead of mysteriously appearing under an employee's account. I like that accountability, but autonomy plus corporate context raises the stakes fast. Google pairs the agent with real-time spending limits, smart routing, and multimodal orchestration so a long task can't consume an unlimited budget. It's available across mobile, desktop, command line, workspace, Microsoft 365, ServiceNow, and Slack. On, Shopify, and PayPal tested it early. Google also names BNP Paribas, Merck, Orange Spain, and Ulta Beauty as customers. The next consequential move would be exposing more of this model selection and task surface through developer APIs. GitHub Copilot can now execute local commands inside a sandbox governed by a policy chosen by the user or company. The feature became generally available October 7 across the terminal-based AI coding agent GitHub Copilot CLI, the Copilot app, and VS Code Sessions using Agent Host. A policy can restrict file system access, internet and local network connections, GIT credentials, and GitHub command line credentials. When a tool call crosses a forbidden boundary, the operating system blocks it. Finally, a concrete answer to can the agent work on my repository without inheriting my entire laptop? How does GitHub Make One policy behave consistently across three operating systems? Microsoft Execution Container, shortened to MXC, translates the shared policy into native controls on Windows, Mac OS, and Linux. Those platforms isolate processes differently, but teams can describe the desired boundary once. The protection can also cover connected local tools, including supported language servers and local MCP servers. That matters because an agent's effective reach includes the tools it invokes, not merely its own process. GitHub deliberately separates isolation from model choice, so changing models doesn't silently alter the machine permissions around them. Enterprise administrators can require the sandbox through managed settings that developers can't weaken, and GitHub includes it with Copilot at no extra charge. That's a substantial policy move. Autonomous coding becomes easier to authorize when a security team can centrally constrain writable folders, reachable hosts, and visible credentials. The remaining tension is usability. Python and Node projects often need package registries, local servers, build caches, and several working directories. A policy that's too broad weakens the protection, one that's too narrow interrupts normal work. At least that trade-off now lives in an explicit policy instead of a blur of repeated approval dialogues. The terminal-based AI coding agent GitHub Copilot CLI can now discover supported models already running through Alarma on the same machine. Its model picker lists those local choices beside configured providers and GitHub's cloud models. Selecting one shows the provider and endpoint, then offers either to add and use it immediately or save it without switching. The current session can use the confirmed model without restarting the agent. Discovery doesn't install Alarma or download waits, and only models supporting tool calls and streaming appear. If the local service can't be reached, the picker reports that failure directly. It's a modest interface change, but it removes the awkward gap between running a model locally and persuading an agent product to recognize it. That's clean, with one privacy nuance worth keeping straight. Choosing a local model doesn't automatically enable Copilot's offline mode or stop GitHub telemetry. Offline operation remains a separate setting, and selecting a remote provider can still send prompts and code context over the network. GitHub has also announced intelligent routing for local models, with availability still to come. That could eventually let the product choose among local options according to the task. For now, Discovery removes configuration friction without pretending that local model and entirely offline product mean the same thing. Perplexity has released PPLX Embed V2 Late in two sizes, a 600 million parameter model designed for edge hardware such as phones and laptops, and a 9 billion parameter model aimed at high-quality search indexes. Both carry the MIT license, so they can be downloaded, modified, and self-hosted. Embedding models convert content into numerical coordinates that preserve semantic similarity. Search systems can then retrieve passages related in meaning even when they don't use the same words. That's the machinery behind many document search, recommendation, clustering, and duplicate detection systems. The small and large pairing is smart. The compact model can put semantic search inside a desktop or mobile application without requiring a network request. That keeps private collections on the device and avoids round-trip latency. The 9 billion parameter version fits teams willing to spend more compute for retrieval quality while retaining control over infrastructure and data. Perplexity reports a score of 92.4% for the larger model on Madca, placing it among strong retrieval systems on that evaluation. But the uneven result matters as much as the headline. The same model scores 61.2% on 6DURI V3 Markdown, its weakest-cited result. That's a meaningful limitation for collections dominated by markdown or rendered documents. A broad benchmark win doesn't erase a weak content type that may represent most of a developer's actual knowledge base. The MIT license still makes both variants unusually flexible. The large version chases index quality, while the smaller model lets embeddings travel with the product and run near the user. Embedding Gemma 2 sounds almost too neat. Text, code, images, video, and audio all become points inside the same 768-dimensional space. What does that buy an application beyond a very impressive sentence? It lets unlike media become searchable by meaning. A spoken query can retrieve a relevant frame, document, code fragment, or audio clip because the model places related content near one another numerically. Google DeepMind's open model has 740 million parameters and ships under Apache 2.0. It loads through sentence transformers, and unsloth offers a GGUF build for local runtimes. The full model combines a 270 million parameter text backbone, a 170 million parameter vision encoder, and a 300 million parameter audio encoder. Those media encoders are modular, so a text and image product can emit audio and run an effective 440 million parameter configuration. That modularity is the exciting part. A photo library can search images with natural language descriptions. A meeting archive can connect spoken moments to related documents. A developer tool can place code and technical explanations in the same retrieval space. Inputs may also interleave media within an 8192 token context. Its nested embeddings preserve useful structure at shorter lengths, letting the standard vector shrink from 768 dimensions to 512, 256, or 128. Smaller vectors mean less storage and faster similarity searches across large collections. Google reports that shrinking to 256 dimensions cuts storage to roughly one-third while its multilingual score moves only from 61.36 to 60.41. At 128 dimensions, multimodal quality falls more sharply. The model card also warns that float 16 inference can produce invalid numbers or degraded embeddings, so it calls for bfloat 16 or float 32. For code retrieval, Google reports 78.68 on MTEB code V1, versus 68.76 for the prior embedding gemma. That's an unusually useful package, adjustable storage, optional media encoders, local access, and documented limits around numerical precision and aggressive compression. NVIDIA researchers have introduced PivotO PD, a training method aimed at a familiar agent failure, making one bad decision early, building several later steps on top of it, and never recovering. The technique uses on-policy distillation, which means the agent learns from trajectories it produced during its own training rather than relying only on a fixed archive of expert examples. It gives extra weight to pivotal mistakes, the early choices that changed everything downstream. That distinction matters. Plenty of systems can revise a sentence after receiving criticism. Recovering from a wrong tool, false assumption, or bad route several turns earlier requires recognizing that the current trouble began somewhere else. PivotO PD trains directly on those forks. The learner sees where a stronger policy would have pivoted, then absorbs that correction into its own behavior. NVIDIA reports the best average score across three agent benchmarks when compared with 13 alternative training setups. I don't buy three benchmarks as proof that agents now self-correct reliably everywhere. But NVIDIA chose the right problem. Multi-step work often collapses through compounding error, not because every later action is individually absurd. An agent that identifies the pivotal turn can revise its plan instead of polishing the consequences of a bad premise. That's especially important when a task has already consumed tools, time, or external resources before the agent notices it's heading the wrong way. Exactly, and that turns recovery into behavior that can be trained, not merely a prompt wrapped around the base model. Reproduction outside NVIDIA's experiments will determine how far it travels. If the method carries into coding, browsing, or physical control agents, correction can become part of the learned policy itself. That would be more durable than asking a model to critique its latest answer after the decisive mistake happened 10 actions earlier. Miro's lab is training agents inside worlds defined by executable code and displayed through a learned video renderer. The program holds the objects, rules, and goals. The renderer converts that state into camera frames at more than 30 frames per second, at 480 by 832 pixels on 1H100. Pre-trained agents act through what they see, while the underlying simulation remains governed by inspectable code rather than an opaque video generator. Here's the wild part, between rounds, agents write down what worked, and those notes seed the next group. Across four rounds, a wheel loader progressed from clearing rocks to delivering one into a bunker and parking with 31 seconds left. Agents solving a single-lane bridge swap learned to yield on the bank and recenter. The work also covered hide-and-seek, sheep herding, and timed engagement with a dog. Executable worlds preserve consistent rules, live rendering keeps visual interaction, and past-forward notes let later agents inherit tactics without retraining the environment. OpenAI published results on open mathematical problems from an internal frontier model and released Lean formalizations with supporting research material on GitHub. Lean is a proof assistant. Mathematics is written in a programming-like language, and every logical step must satisfy rules checked by software. That gives researchers something more concrete than an elegant explanation produced by a language model. So when people say the proof checks, what has actually been established? The checker establishes that the encoded conclusion follows from the declared assumptions through valid formal steps. It doesn't automatically establish that the formal statement perfectly captures the informal problem, or settle every question around the selected axioms. Humans still compare the formal theorem with the mathematical claim. But the repository exposes the proof scripts, letting specialists inspect the construction, execute the checker, and compare the formal result with the prose account. A plausible mathematical narrative may hide a subtle gap. A machine-checked artifact makes the logical chain inspectable. The announcement drew more than 1,300 points on Hacker News, but independent examination of those statements and proofs matters much more than the attention around their publication. Cactus Compute has released Whistle, an open speech recognition model occupying 16.9 MB and running through the company's dependency-free C++ engine. It handles clips up to 30 seconds at 16 kHz mono in English, German, French, Spanish, Italian, Dutch, and Polish. Automatic language detection appears as a generated token rather than a separate external result. 17 MB is tiny enough to change where speech recognition belongs. It can live inside a phone, watch, desktop utility, embedded device, or browser component instead of treating cloud transcription as the default. On an Apple M4 Pro, Cactus reports first token latency of 5.9 ms for 5 seconds of audio, 11.1 ms for 10 seconds, and 36.3 ms for 30 seconds. The company also reports that whistle beats whisper bass across several speech datasets, while whisper bass occupies 145.3 MB. Those numbers come from Cactus, but the size difference alone is striking. Underneath, eight encoder blocks turn the sound into an internal representation, and eight decoder blocks produce the text. Each decoder layer can attend back to the encoded audio. The engine reads the encoder output once when the clip loads and caches it while searching among five candidate transcriptions, which avoids repeating expensive work. That reuse helps explain how a tiny local package can search multiple possible outputs without reprocessing the sound from scratch each time. And there's a sharp agent angle. The same binary can load whistle beside Cactus's needle text model, then turn audio into structured function calls. It returns selected functions, recognized text, and timing as structured data, while an application may keep the raw transcript away from the calling layer. Pre-built binaries cover 17 targets, including macOS, Linux, Android, iOS, watchOS, Windows on ARM, RISC-V, MIPS, browsers, and WebAssembly components. That breadth makes Whistle look less like a laboratory miniature and more like a portable voice input layer for local software. OpenAI began rolling out GPT-6 in ChatGPT worldwide on October 7. The biggest product change is Intelligent UI, which lets ChatGPT place visuals and interactive experiences directly inside a reply. Instead of producing text that describes an interface somebody must build elsewhere, the chat can present something a user can inspect and manipulate immediately. That shifts the response from an explanation toward a small working environment. Okay, that may matter more than another benchmark crown. A financial explanation can become an interactive chart. A plan can become a usable control surface. A generated concept can arrive as an experience rather than a paragraph describing one. OpenAI is also promoting faster responses, and the published configuration associated with the announcement specifies a 4,096 token maximum output for this version. The interface layer is the bigger departure because it changes what the user receives, not just how quickly the model produces it. The launch drew immediate attention, including a Hacker News score of 748 on its first day. But Intelligent UI deserves to be separated from launch day enthusiasm. Chat products have spent years asking people to copy answers into spreadsheets, editors, dashboards, and app builders. Interactive output can collapse some of that distance. It also raises questions about state, accessibility, export, trust, and which actions an embedded component may perform. A chart that merely responds to a slider is one thing. A control that changes external data carries a different level of consequence. Access will decide how broad the impact becomes. GPT-6 is rolling out globally through ChatGPT, and the announcement centers the experience there. If the components behind Intelligent UI later reach third-party applications through an API, developers could build products where the model chooses both the content of an answer and the best way to present or operate it. If the capability remains tied to ChatGPT, OpenAI still gains a distinctive application layer, but everybody else gets a product pattern to chase, not a shared building block. TokenRouter lets a small model and a large model collaborate within one response, deciding token by token which model should continue. On its reference setup, the newer IPS paper reports 372.48 tokens per second, compared with 134.9 for the official system, roughly 2.76 times faster. Each model keeps its stored attention state on its own server, while TokenRouter transfers only the new token suffix and routing information. That's more ambitious than sending easy prompts to a cheap model and hard prompts to an expensive one, a single answer can move between them. The scheduler batches work across both models, and the smaller one can keep generating while the larger model handles its portion. Across QN pairings on 8A100 GPUs, the paper reports speed-ups from 1.99 to 3.21 times. It requires both models, coordinated scheduling, and separate cache management, but it turns model choice into something that can happen during generation rather than only before the request begins. Google Cloud is also presenting the Gemini agent as one cloud-hosted interface for questions, knowledge work, media creation, and code that can be written and executed from a single prompt surface. Developers get one API target instead of independently wiring a research system, document tool, media generator, and coding environment. The promise isn't merely one chat window, it's one entry point that can choose different forms of work behind the request. That sounds attractive, but doesn't it overlap almost completely with the objective-taking workplace agent we discussed earlier? It's the same larger direction viewed from another surface. The workplace announcement emphasizes autonomy, identity, delegation, company systems, and controls. This one emphasizes a universal interface, one prompt and one API spanning several kinds of work. For organizations already keeping data and applications in Google Cloud, fewer separate integrations can reduce orchestration overhead and preserve more context as a job moves from research to production. The hard part is continuity. Research, media generation, and code execution require different tools, permissions, and representations of context. A universal prompt box earns its name only if work can move among those tasks without losing relevant facts, confusing intermediate outputs, or weakening the controls around each action. Nanobot has 48,895 stars, up 968 in 30 days. Its 0.3.5 release and October 9 repository update keep the compact Python agent framework active, combining a web interface, memory, tools, MCP support, multi-agent workflows, and chat integrations. Codebase memory MCP sits at 46,200 stars and grew faster, 3,465 stars, or 8.1%, in 30 days. Its 0.11 release packages persistent code knowledge graphs and submilisacent queries across 158 languages into a static binary with no external dependencies. Those two fit together neatly. Nanobot supplies a lightweight runtime for action, while codebase memory gives an MCP-capable coding agent a persistent repository map instead of repeatedly loading source into its prompt. REA brings 33,198 stars on its first tracked appearance. Its agent 6.1 release shipped October 9 and coordinates agents around reverse engineering, moving from observed application behavior toward native binaries while returning structured decisions rather than only raw disassembly. REA has the freshest release, while codebase memory has the strongest recent growth. Together, the projects show agent infrastructure specializing into distinct jobs, a compact runtime, a graph layer for code understanding, and an agent-guided route through binary analysis. Step 5 preview is the major new hosted model entry. Stepfun describes it as a sparse mixture of experts system with 27 billion active parameters out of 600 billion total and a 1 million token context window. It's available through OpenRouter's API and positioned for agentic software engineering and professional work. Long context combined with relatively small active capacity makes it a significant preview, though its behavior may continue changing before a broader release. Embedding Gemma 2 is the open, local counterpart, 740 million parameters mapping text, code, images, video, and audio into one 768-dimensional space. It carries Apache 2.0 licensing, works through sentence transformers, and has a GGUF build for local inference. Its strongest differentiator is modularity, text, vision, and audio components can be combined according to the workload along with shorter 256-dimensional embeddings that preserve most of Google's reported multilingual score while cutting storage substantially. JEEV 27BVL from Autotrust is trending on hugging face with 3,265 likes and more than 1.5 million downloads. It's an image-to-text decision model built in the Quen 3.5 family and distributed through the transformers and safetancers ecosystems. Its tags emphasize typed decisions, calibrated probabilities, and two modes labeled System 1 and System 2, language borrowed from fast intuitive judgment and slower deliberative reasoning. That framing is interesting for visual workflows where an application needs a structured decision rather than a free-form caption. A quality control system, document processor, or visual assistant often needs a choice plus confidence, not a lyrical account of the image. Typed output can also make a decision easier for ordinary software to consume because the result fits a known structure. The public activity shows meaningful attention around a 27 billion parameter vision language model built around explicit decisions and probabilities. Deployment details such as license, context capacity, hardware needs, and evaluation scope remain tied to the particular model card and weight package being used. Architect launches Liquid Inference. A real-time auction for LLM inference introduces a marketplace where providers bid to serve each request and the buyer pays the lowest offer satisfying its policy. Integration can come down to changing a base endpoint. What happens when a trusted model repo changes? Unslow Studio rechecks before it runs approaches infrastructure from the trust side, studio fingerprints custom code, binds approval to that artifact, blocks flagged weights, checks package contents, and confines tools in site operating system sandboxes. Commission holds special meeting of scientific panel on frontier AI safety and risks brings regulators into the same picture. The European Commission's 60 expert scientific panel and the AI office are preparing questions for frontier model developers and recommendations for systemic risk evaluation and cross-border market surveillance. So cost, software trust, and public oversight are all tightening at once. An auction chooses who serves the request, artifact controls govern what can execute, and regulators shape how frontier risks are examined across national markets. For the supporting references and written details behind these developments, look at the show notes at tobyonfitnesstech.com. Thanks for listening to AgentStack Daily. We'll be back soon.