# AgentStack Daily EP051 — OpenClaw 2026.5.12, Hermes Foundation, Claude Code Background Controls, and Gemini Agent Deployments

[NOVA]: I'm NOVA, and this is AgentStack Daily. Today starts with the part of agent infrastructure that decides whether the whole stack feels boring in the good way: installs, channel reliability, auth profiles, background sessions, and deployment controls. OpenClaw v2026.5.12 is the host-quality release to look at first. It trims the core install, makes Telegram polling more resilient, tightens Codex and OpenAI auth behavior, hardens plugins and gateway delivery, and cleans up browser, sandbox, and config paths. Beside it, Hermes Agent 2026.5.16 is a distribution and runtime jump: native Windows beta, PyPI installation, faster startup, a local OpenAI-compatible proxy, real vision and video tool paths, browser speedups, and verification after file mutations. [PAUSE]

[ALLOY]: I'm ALLOY. Claude Code is the adjacent local coding-agent story. Versions 2.1.143 and 2.1.142 add plugin dependency enforcement, projected context cost, background-session flag preservation, PowerShell behavior, worktree isolation choices, MCP timeout fixes, and stop-hook caps. Then we move to two Google platform changes. Gemini Enterprise Agent Platform now has agent revisions, traffic splitting, and Priority PayGo. And Google's Interactions API is migrating from flat outputs to a typed steps timeline. The practical question across the episode is simple: what should an operator upgrade, test, and instrument before these changes become production assumptions? [PAUSE]

## [00:00–24:00] OpenClaw release block — the upgrade starts with install size, polling resilience, and background agents

[NOVA]: The fastest way to understand today's release slate is to start at the surfaces that break first in real agent work. A demo can survive a bloated install, a fragile message adapter, a vague auth failure, or a background worker that wakes up with the wrong settings. A daily operator cannot. A serious agent host has to install cleanly, survive channel stalls, keep credentials scoped, resume background work without changing its permissions, and report actual outbound content even when that content is a rich card or a tool result rather than plain text. [PAUSE]

[ALLOY]: That is why OpenClaw v2026.5.12 matters. It is not only adding a shiny button. It is reducing dependency cones, isolating Telegram polling, preserving local spool state, improving Codex and OpenAI credential behavior, repairing gateway deltas, and making rich replies count as real replies. Those are the kinds of fixes that make an operator stop thinking about the plumbing. If a group-media message should be ignored because mention gating is on, it should not be downloaded first. If a scheduled announcement renders HTML, formatting should survive. If a reply is only a card with buttons, it should not vanish because a plain-text field is empty. [PAUSE]

[NOVA]: Hermes Agent 2026.5.16 widens the lens. It makes the agent easier to install, faster to start, more viable on Windows, and more useful as a local provider bridge. A local OpenAI-compatible proxy for OAuth-backed providers is especially interesting because it lets tools that already speak OpenAI style APIs point at accounts and providers that otherwise live behind a different authentication path. That can change the center of gravity for local tooling: Hermes becomes not just a chat agent, but a provider hub. [PAUSE]

[ALLOY]: Claude Code's recent changes complete the operator picture. Background work is useful only when it preserves the things that made the foreground session safe: model, effort, settings, MCP config, additional directories, plugin directories, strict MCP options, fallback model, and permission mode. Plugin dependency enforcement is equally practical. If one plugin depends on another, disabling the dependency should not leave the system in a half-broken state. This is the mature-agent theme for the day, without needing a slogan: less hidden state, more explicit rollout, more testable recovery. [PAUSE]

[NOVA]: There is also a reason to front-load the release readout instead of treating it as housekeeping. These upgrades change the workflow defaults builders inherit. If the install is smaller, a new operator can start with fewer unrelated failures. If the channel adapter spools locally, an approval workflow can survive an event-loop stall. If auth profiles are respected by media and Codex routes, a mixed-provider workflow has fewer false reauthentication loops. If background sessions preserve settings, an unattended coding workflow can wake up with the same authority it had when it started. Those are not abstract improvements; they change whether teams trust agents with longer jobs. [PAUSE]

[ALLOY]: The first build pattern is to treat the release as an upgrade rehearsal. Do not run one command, see a prompt, and declare success. Build a tiny operator workflow for each surface: one channel workflow, one provider workflow, one plugin workflow, one gateway workflow, one browser workflow, and one background coding workflow. Each should have an expected state before the upgrade and an expected state after the upgrade. That makes the release measurable. It also gives the team a rollback trigger if one surface regresses. [PAUSE]

### Agent-stack release readout: OpenClaw v2026.5.12, Hermes Agent 2026.5.16, and Claude Code 2.1.143/2.1.142 move the operator surface

[NOVA]: Story one is the agent-stack release readout: OpenClaw v2026.5.12, Hermes Agent 2026.5.16, and Claude Code 2.1.143 and 2.1.142 move the operator surface. Start with OpenClaw's dependency shape. Bedrock, Bedrock Mantle, Slack, OpenShell sandbox, Anthropic Vertex, WhatsApp, and related provider packages move out of the mandatory core runtime. That sounds like packaging housekeeping, but for agent hosts it is a real reliability improvement. Optional providers should not become platform-specific build failures for users who never enabled them. A leaner core means fewer surprise native builds, fewer transitive version conflicts, and fewer update failures caused by a service that is not part of the active configuration. [PAUSE]

[ALLOY]: Dependency cones are a quiet operational risk. If the base agent package pulls every provider, every channel adapter, and every sandbox path by default, then the base install becomes hostage to the most fragile optional dependency. The better model is a small core with explicit extras. Operators can then decide whether they need Slack, WhatsApp, Bedrock, Vertex, a sandbox backend, or a special provider plugin. The upgrade test for this part is not glamorous: create a clean environment, install the core, start the host, then add only the extras you actually use. The absence of unused providers is the feature. [PAUSE]

[NOVA]: The second OpenClaw cluster is channel resilience. Telegram polling now runs in an isolated worker with durable local spooling. The design target is clear: a main event-loop stall should not be enough to lose or badly delay inbound Telegram messages. In agent operations, chat is not just a UI. It is a trigger bus, approval bus, status bus, and evidence bus. If the main agent is busy with a long tool call, the channel adapter still needs to behave like transport infrastructure. Isolated polling plus local spool is one answer to that failure mode. [PAUSE]

[ALLOY]: The release also tightens several Telegram and messaging details that operators will notice. Lazy cron announcements preserve rendered HTML formatting. Group media that does not mention the bot can be skipped before download when mention gating is active. Tool-progress-only draft bubbles are cleaned up before the final answer rotates in. Rich-only replies, cards, buttons, and source replies are treated as outbound content instead of being dropped as empty. The practical smoke test after upgrading is one streamed answer, one scheduled announcement, one group media edge case, one rich card, and one interrupted turn. [PAUSE]

[NOVA]: Codex and OpenAI paths get a big reliability pass. Auth-profile-backed media tools stay available when credentials live in the agent auth-profile store rather than in environment variables. Codex OAuth refresh errors are classified more cleanly, and high-confidence app-server refresh failures avoid collapsing into vague runtime failures. Selectable OpenAI agent models are treated as Codex runtime requirements even when the primary model config is Anthropic. That matters in mixed-host setups where Claude is the primary assistant but Codex or OpenAI-backed tools still need valid model and credential paths. [PAUSE]

[ALLOY]: The CODEX_HOME behavior is also important. OpenClaw keeps per-agent CODEX_HOME isolation without rewriting HOME by default. That distinction prevents two bad outcomes. On one side, you do not want all agents sharing the same Codex credential and cache state accidentally. On the other side, rewriting HOME can break ordinary subprocesses that expect normal user-home discovery. The release is choosing narrower isolation: isolate the Codex state you mean to isolate, but avoid turning every subprocess into a strange environment experiment. [PAUSE]

[NOVA]: Plugin mechanics get the next set of changes. Plugin installs preserve peer dependencies, handle pnpm 11, restore a deprecated memory SDK subpath for companion plugins, scan runtime entry points more narrowly, discover provider plugins through structured setup credentials, and preserve install records through doctor cleanup. The operator-level reading is that plugin installation is being treated as a dependency graph, not as a folder copy. If a plugin depends on a peer, if a package manager changes behavior, or if doctor cleanup runs after a failure, the system should keep enough state to recover instead of wedging the host. [PAUSE]

[ALLOY]: Gateway and session protocol changes are equally practical for developers building clients on top of OpenClaw. Session history now carries monotonic transcript sequence numbers. Streaming can send explicit delta text and replace frames. That means a client no longer has to guess how to diff assistant output locally or infer ordering from timing alone. Sequence numbers are one of those small protocol features that become essential as soon as reconnects, retries, or multiple consumers enter the picture. The test is not just a plain text response. Test reconnects, replacement frames, rich replies, message-tool-only responses, and media or card outputs. [PAUSE]

[NOVA]: Security and config hardening round out the OpenClaw release. Windows user-profile roots are included in sandbox blocked home roots so credential-bearing folders stay denied even when HOME points somewhere else. Provider credentials resolve through structured secret references rather than broad environment-variable-looking strings, reducing accidental credential inference. Semantic config mutations are serialized and retried centrally, reducing clobber risk when concurrent commands edit the same configuration. Browser CLI commands request the existing operator-admin gateway scope, which avoids unnecessary approval-loop noise. [PAUSE]

[ALLOY]: None of those items are headline-grabbing, but they are exactly the difference between a fun local agent and a safe daily runtime. Credentials should not leak because a sandbox guessed the wrong home root. Config should not be corrupted because two commands raced. Browser commands should not ask for a new kind of permission when an operator-admin scope already exists. Structured secret references should make credential intent explicit. This is host maintenance, and host maintenance is where trust is built. [PAUSE]

[NOVA]: Hermes Agent 2026.5.16 is the broader runtime and distribution story. The release names native Windows support as early beta. That includes a PowerShell installer, native subprocess and PTY paths, taskkill-based process management, MinGit auto-install, Python stub detection, Ctrl+C preservation, and Windows-specific fixes. The caveat is beta, but the direction is major. Agent tooling that only feels natural on Unix-like systems leaves a lot of developer and enterprise machines out of the first-class path. Windows support is not a checkbox; it touches process control, terminals, signals, paths, Git installation, shell defaults, and browser integration. [PAUSE]

[ALLOY]: Hermes also ships a real PyPI installation path: pip install hermes-agent, then run hermes. That changes the adoption loop. A user should not have to clone a repo, inspect a custom installer, and debug a shell script before trying an agent. PyPI distribution, lazy dependencies, and advisory checks together say the project is treating install as product. Lazy dependencies defer heavy provider libraries until first use. Installer fallbacks move through extras tiers. Install and update scans look for unsafe versions. The result should be faster first run and fewer unnecessary provider failures. [PAUSE]

[NOVA]: The performance numbers are worth translating into daily feel. Hermes says cold start drops by roughly nineteen seconds through skills caching, lazy imports, disk-cache-first model lookup, deferred provider libraries, and parallel doctor checks. Hermes tools for all platforms falls from about fourteen seconds to under one and a half seconds. Browser console evaluations become dramatically faster by reusing the supervisor's persistent CDP WebSocket instead of opening a fresh DevTools session per call. For browser-heavy debugging, persistent CDP is not an implementation detail. It decides whether the loop feels instant or like every observation begins with setup tax. [PAUSE]

[ALLOY]: The local proxy may be the most strategically interesting Hermes feature. Hermes proxy exposes OAuth-authenticated providers through an OpenAI-compatible local endpoint. Tools such as Codex, Aider, Cline, or editor extensions often know how to call an OpenAI-style API. They may not know how to handle every OAuth-backed consumer account or provider-specific login path. A local compatibility proxy can bridge that gap. The operator question becomes: which local tools should point at Hermes as their provider bridge, and which should keep their direct provider configuration? [PAUSE]

[NOVA]: Hermes also expands its tool surface. Cross-session one-hour Claude prompt caching can reduce repeated-prefix cost across resumes and new sessions. Vision analyze now passes pixels to vision-capable models rather than reducing the image to text first. A unified video generate tool supports pluggable providers. Computer use gets a non-Anthropic-capable backend through cua-driver. Handoff can move the live session to another model, persona, or profile while preserving context and tool history. X search and browser improvements make it more useful as a research and automation hub. [PAUSE]

[ALLOY]: For code-writing agents, two verification features deserve special attention. LSP semantic diagnostics run after write file and patch operations, so the agent can see language-server errors on the changed file before downstream work continues. A per-turn file-mutation verifier footer tells the agent what actually changed on disk after a turn that wrote files. That is a direct answer to a familiar failure mode: the model says it edited the file, but the patch missed, modified the wrong region, or introduced a type error that is visible immediately. Diagnostics and mutation summaries do not replace tests, but they shorten the path to the first real correction. [PAUSE]

[NOVA]: Claude Code 2.1.143 and 2.1.142 round out the CLI-agent side. Plugin dependency enforcement means disabling a plugin can refuse when another enabled plugin depends on it, and the system can show a disable-chain hint. Enabling a plugin can force-enable transitive dependencies. The marketplace browse pane shows projected context cost per turn and invocation. That is useful because a plugin is not free just because it is installed. If it injects context or runs frequently, it has a budget effect. Making that cost visible turns plugin management from vibes into operations. [PAUSE]

[ALLOY]: Background worktree isolation gets a new choice with worktree background isolation set to none. That lets background sessions edit the working copy directly when Git worktrees are impractical. It is not the safest default for every team, but it is a real-world escape hatch. Worktree cleanup also no longer falls back to destructive removal if git worktree remove fails. That matters because cleanup paths are dangerous. A failed cleanup should be visible and conservative, not an invitation to delete more aggressively. [PAUSE]

[NOVA]: The background-session fixes are the ones I would test first. Background sessions preserve model and effort level after waking from idle. The background command preserves MCP config, settings, add-dir, plugin-dir, strict MCP config, fallback model, and bypass-permission availability across respawn or detach. Claude agents accepts flags for add-dir, settings, MCP config, plugin directories, permission mode, model, effort, and skip-permission defaults. Background sessions launched from the dashboard honor the configured default permission mode. That is the difference between a worker that resumes the same job and a worker that resumes with a subtly different safety contract. [PAUSE]

[ALLOY]: MCP HTTP and server-sent-event tool calls now respect the configured timeout instead of being capped at sixty seconds. Stop hooks that keep blocking now end with a warning after eight consecutive blocks unless overridden. PowerShell behavior is improved. Plugin dependencies are stricter. Background reliability gets better. The summary for operators is clear: after upgrading Claude Code, run an actual background job, let it idle, wake it, detach it, check MCP config, check permission mode, and force one long MCP call. Do not treat the version number as proof that your local workflow survived. [PAUSE]

[NOVA]: So the release checklist is concrete. For OpenClaw, test install extras, Telegram polling and spool behavior, rich replies, Codex auth profiles, gateway deltas, plugin installs, browser scope, sandbox blocked roots, and concurrent config edits. For Hermes, test PyPI install, Windows if relevant, cold start, persistent browser console, the local proxy, vision, video, handoff, LSP diagnostics, and mutation verification. For Claude Code, test plugin dependency chains, projected plugin cost, background flags, worktree mode, MCP timeout, stop hooks, PowerShell, and dashboard-launched background sessions. [PAUSE]

## [24:00–34:00] Gemini Enterprise Agent Platform adds agent revisions, traffic splitting, and Priority PayGo

[ALLOY]: Story two is Gemini Enterprise Agent Platform adds agent revisions, traffic splitting, and Priority PayGo. Google's May fifteenth update adds a deployment primitive agent teams need: immutable deployed-agent revisions with traffic splitting. Before this, many agent deployments behaved like mutable endpoints. You changed the prompt, tools, routing, model settings, or container code, and the endpoint simply became different. Rollback then depended on how disciplined your release process was outside the platform. Revisions give the agent version a named deployment artifact. Traffic splitting lets a team move a slice of traffic to a new revision while the old revision still serves most users. [PAUSE]

[NOVA]: That sounds like standard software release practice, and that is exactly why it matters. Agents need the same rollout discipline as services, plus extra behavioral metrics. A deterministic API canary watches error rate, p95 latency, and maybe saturation. An agent canary should watch all of that plus task completion, tool-call count, escalation rate, user correction rate, retrieval miss rate, refusal rate, cost per successful outcome, and latency by tool path. A prompt tweak can reduce hallucinations but double tool calls. A tool change can improve success for one class of request and break another. Without revision-aware observability, those changes blur together. [PAUSE]

[ALLOY]: The logging recommendation is simple: revision IDs should appear in traces, logs, evaluation records, feedback records, and support bundles. Endpoint name alone is not enough. If a user reports that the agent suddenly started choosing the wrong tool, the investigation needs to know which revision served the turn, what traffic share that revision had, which model and tools were active, and whether the same behavior appeared in offline evals. Revision IDs are the join key between rollout and quality. [PAUSE]

[NOVA]: Traffic splitting gives teams a safer lane. Start with a small percentage of production traffic or a narrow internal cohort. Watch latency, cost, tool errors, task success, and human escalation. Then roll forward, pause, or roll back. The important difference from ordinary web rollout is that agent quality is partly semantic. You may need evaluation harnesses, human review, and sampled transcript inspection alongside numeric telemetry. A revision can be operationally healthy and behaviorally worse. Traffic splitting gives you a way to find that before everyone sees it. [PAUSE]

[ALLOY]: Priority PayGo, generally available one day earlier, adds the cost-and-latency side. Provisioned Throughput is best when traffic is predictable enough to justify a commitment. Standard PayGo is flexible but can have more variable performance. Priority PayGo sits between them: more consistent performance than standard consumption without the same upfront throughput commitment. For production agents, that maps to workloads that are important but bursty: customer-support triage, incident helpers, internal research assistants, or workflow agents that spike during business hours. [PAUSE]

[NOVA]: The builder trap is mixing rollout diagnosis with capacity variance. If a new agent revision looks slower during a canary, is the revision causing deeper retrieval, more tool calls, and longer reasoning? Or is the platform under variable load? Priority PayGo can reduce one source of noise so the rollout signal is easier to read. It does not make a bad revision good, and it does not erase cost. Per-revision metrics still need to show model calls, tool calls, token usage, latency, and success rate. [PAUSE]

[ALLOY]: The minimum useful Gemini agent rollout dashboard should show revision, traffic share, latency, model and tool costs, tool errors, human escalation, task success, refusal rate, and rollback state. It should also separate platform latency from agent behavior where possible. If the new revision increases retrieval depth, that is a product choice. If Standard PayGo variance spikes at the same time, that is capacity noise. The point of the May releases is that agent deployment can now look more like software release management. Use that discipline. [PAUSE]

## [34:00–43:00] Google's Interactions API migration replaces flat outputs with a typed steps timeline

[NOVA]: Story three is Google's Interactions API migration replaces flat outputs with a typed steps timeline. The breaking-change guide says the legacy schema is being removed on June eighth. The old shape returned a flat outputs array. The new shape returns a steps array with type discriminators and a polymorphic response format. For a simple application, it may be tempting to grab the last text item and keep moving. For agent systems, that would miss the point. A turn is becoming a structured timeline, not just a final generated string. [PAUSE]

[ALLOY]: The practical migration starts with request and response readers. If your code assumes outputs at the top level, update it. If fixtures in tests include only the old shape, add new fixtures. If your database stores only final text, consider storing the raw interaction object or at least the step timeline. If your replay tools, eval tools, support tools, or audit tools parse old outputs, they need a compatibility layer. The removal date is close enough that teams should not leave this to the last week. [PAUSE]

[NOVA]: Response configuration changes too. Instead of response mime type, output controls move under response format. That is cleaner for a growing API because it avoids a pile of one-off request fields. A polymorphic response format gives the platform room to add structured modes without turning the request schema into unrelated switches. For SDK maintainers, this is a type-generation and compatibility issue. For application builders, it is a persistence and parser issue. Your app should know which response format was requested and which step types came back. [PAUSE]

[ALLOY]: The migration-control detail is the Api-Revision header. That lets teams pin behavior during the transition rather than discovering schema removal through production failures. A good migration plan is dual-read support, raw-object capture during the transition, updated summaries and replay tools, and a small suite of old transcripts or interactions run through the new parser. If agent logs are used for support, evals, analytics, or audit, do not flatten away the step types just to preserve an old text-only mental model. [PAUSE]

[NOVA]: The reason the steps timeline matters is future capability. Google says the new shape supports future features such as mid-flight steering and asynchronous tool calls. Those features need event structure. A tool call may start, wait, resume, produce intermediate output, or receive steering before final answer. If your client collapses the timeline into one string immediately, you might be technically compatible while becoming architecturally behind. The better design is to store step ID, step type, timestamps, content, tool metadata, and linkage to the interaction. [PAUSE]

[ALLOY]: This lines up with the rest of the episode. OpenClaw is adding cleaner transcript sequences and gateway delta semantics. Hermes is adding diagnostics and mutation verification. Gemini Enterprise Agent Platform is adding revisions and traffic splits. Google's Interactions API is making the interaction itself a timeline. Different layers, same operational lesson: durable systems need structured state. Final text is useful for the user, but it is not enough for debugging, steering, replay, billing, or evaluation. [PAUSE]

## [43:00–47:00] Closing — what to upgrade and what to watch

[NOVA]: The upgrade priority is straightforward. If you operate OpenClaw, test v2026.5.12 against your actual channels, Codex and OpenAI auth profiles, gateway clients, browser commands, plugin installs, sandbox expectations, and config mutation flows. Do not stop at startup success. Send a rich reply. Interrupt a turn. Test group media with mention gating. Reconnect a gateway client. Run a plugin install and a doctor cleanup. Confirm the host behaves like transport infrastructure, not like a lucky demo. [PAUSE]

[ALLOY]: If you operate Hermes, test the new install path, Windows path if it matters to your users, startup speed, persistent CDP browser console calls, local proxy, image and video tools, handoff, LSP diagnostics, and file-mutation verifier on a real repository. The real-repo part matters. A toy prompt will not tell you whether diagnostics fire when a patch creates a semantic error or whether the mutation summary catches the exact files changed. [PAUSE]

[NOVA]: If you use Claude Code background agents, update and verify that background sessions preserve model, effort, settings, MCP configuration, add-dir, plugin directories, strict MCP config, fallback model, permission mode, and PowerShell behavior across detach, idle, and wake. Test plugin dependency enable and disable chains. Test a long MCP call. Test stop-hook blocking. Background agents are only valuable when they continue the same job under the same safety assumptions. [PAUSE]

[ALLOY]: For platform builders, Gemini Enterprise Agent Platform's revisions and traffic splitting are the deployment pattern to copy: agents need canaries, rollback, revision-aware observability, and cost-aware rollout gates. Priority PayGo is useful where latency variance would confuse rollout diagnosis or hurt user experience, but it does not replace per-revision quality metrics. [PAUSE]

## [47:00–56:00] Operator playbook — turn the release notes into safer workflows

[NOVA]: Before the final close, let's make the workflow playbook explicit. The first workflow is an OpenClaw upgrade workflow. Start from the active host inventory: channels, model providers, Codex profiles, gateway clients, browser usage, plugins, scheduled jobs, and sandbox expectations. Then run a staged build of the new host in a clean environment. The goal is not to prove that every integration exists. The goal is to prove that the base runtime starts with only the integrations you actually use. A smaller base runtime means a smaller failure surface, and that is the point of moving optional providers out of core. [PAUSE]

[ALLOY]: The second workflow is channel proving. Pick one real chat channel and run four checks. First, a normal streamed answer, because streaming reveals delta and replacement behavior. Second, a rich answer, because cards and buttons need to count as real outbound content. Third, an interrupted turn, because draft bubbles and progress-only messages should not pollute the final result. Fourth, a gated group-media case, because the agent should not pay download and processing cost for media it was configured to ignore. If those four checks pass, the messaging workflow is closer to transport reliability instead of lucky UI behavior. [PAUSE]

[NOVA]: The third workflow is Codex and provider authentication. Use one profile that depends on structured auth rather than a broad environment variable. Run one media-capable OpenAI tool, one Codex action, and one model switch where the primary agent is not OpenAI. Watch the error classification. A good upgrade turns a refresh problem into a clear authentication event, not an unexplained runtime crash. The build pattern here is simple: every provider lane needs a deliberate credential source, a clear refresh path, and a failure message an operator can act on. [PAUSE]

[ALLOY]: The fourth workflow is plugin governance. Treat plugins as a dependency graph. Install the plugin set you use. Disable one optional plugin and confirm nothing unrelated breaks. Try to disable a dependency and confirm the system gives a dependency-chain warning instead of creating a half-enabled state. Review projected context cost where the platform exposes it. A plugin that silently adds large context on every turn is not just an extension. It is a recurring budget decision. Mature builder workflows make extension cost and extension dependency visible before the incident. [PAUSE]

[NOVA]: The fifth workflow is gateway-client compatibility. If you build against OpenClaw's gateway, test more than one happy-path answer. Test sequence ordering, reconnect, replacement frames, rich cards, source replies, media, and a message-tool-only answer. A client that handles only final text is easy to write and easy to break. A client that stores transcript sequence, delta, replacement, content type, and delivery state is more work, but it is the client you want when the agent runs all day. This is the same architectural lesson as the Interactions API migration: keep the timeline, not just the summary. [PAUSE]

[ALLOY]: The Hermes workflow starts with install and startup. Try the PyPI path, then test the first action that pulls a heavier provider dependency. That catches the difference between a fast empty start and a useful first use. Then benchmark the commands that drive your daily loop. If browser console calls are part of your debugging workflow, measure them before and after the persistent CDP path. Performance improvements matter most when they remove hesitation from the operator. If a tool responds in a second instead of fifteen, people use it differently. [PAUSE]

[NOVA]: The Hermes proxy workflow is worth a careful rollout. Do not point every local tool at the proxy on day one. Choose one tool that already speaks an OpenAI-compatible API. Configure it against the local proxy. Run a small set of prompts that cover normal generation, cancellation, error handling, and provider-specific limits. Then decide whether the proxy becomes your default bridge or a targeted bridge for tools that cannot handle the provider's native auth. The build pattern is compatibility first, then convenience. [PAUSE]

[ALLOY]: The code-agent workflow is diagnostics first. Create a branch in a real repository. Ask Hermes to make a small change that should trigger language-server feedback if it goes wrong. Confirm that diagnostics appear after the write or patch operation. Then inspect the mutation verifier summary. It should tell the agent and the operator what changed. This workflow is not about replacing tests. It is about catching the earliest obvious mismatch between what the agent believes and what the working tree actually contains. [PAUSE]

[NOVA]: For Claude Code, use a background-session workflow that resembles production work. Launch a background agent with a specific model, effort level, settings profile, MCP configuration, permission mode, additional directory, plugin directory, and fallback model. Let it idle. Wake it. Detach it. Resume it from the dashboard. Then ask it to call an MCP tool that runs longer than sixty seconds. If any part of that contract changes silently, the workflow is not safe yet. Background agents are not just long-running chats. They are long-running commitments about authority, context, and tool access. [PAUSE]

[ALLOY]: The worktree workflow needs a team decision. If your team can use isolated Git worktrees cleanly, that remains a strong safety pattern. If your repository or tooling makes worktrees impractical, the new no-isolation option is useful, but it should be explicit. Add a policy note in your team workflow: when background work can edit the active working copy, who reviews the diff, what commands are allowed, and how conflicts are handled. The safe build pattern is not one universal setting. It is matching the isolation mode to the repository reality and making the tradeoff visible. [PAUSE]

[NOVA]: For Gemini Enterprise Agent Platform, the workflow is canary by revision, not canary by hope. Create a new revision. Send a small traffic share. Log revision ID everywhere. Compare task success, latency, tool errors, user corrections, escalation, cost, and refusal rate against the current revision. Keep rollback one action away. If latency is critical and traffic is bursty, test Standard PayGo and Priority PayGo separately so you can separate platform variance from agent behavior. The build habit is to make rollout observable before the rollout is dramatic. [PAUSE]

[ALLOY]: For the Interactions API, the workflow is parser migration before product migration. Add the new response reader. Keep the old reader during the transition. Store raw interactions for a while. Update eval replay. Update support tooling. Update any analytics job that assumes final text is the only artifact. Then run old examples through the new steps parser and compare results. The dangerous migration is the one that passes the first demo but breaks audit, support, or evaluation two weeks later. Timeline-aware storage prevents that. [PAUSE]

[NOVA]: If there is one build pattern to take from the whole episode, it is this: every agent workflow needs a state key. OpenClaw gateway clients need transcript sequence. Gemini rollout needs revision ID. Interactions needs step ID. Claude Code background work needs preserved session settings. Hermes code edits need mutation summaries and diagnostics. When the workflow has a state key, you can observe it, compare it, roll it back, and explain it. When the workflow only has a final answer, you are debugging a memory of the system rather than the system itself. [PAUSE]

[ALLOY]: And the second build pattern is to test the boring edge first. Test auth refresh before the big demo. Test group-media gating before the busy channel. Test plugin disable before an urgent upgrade. Test idle wake before a weekend background run. Test parser replay before the removal date. Test rollback before the new agent revision takes most traffic. Boring tests are not a drag on shipping; they are what let agent workflows ship without turning every improvement into a new operator mystery. [PAUSE]

[NOVA]: The third build pattern is to connect every workflow to proof. A channel workflow should produce a message the operator can see. A provider workflow should prove which credential source was used without exposing the secret. A plugin workflow should show the dependency decision. A gateway workflow should show sequence and replacement behavior. A background workflow should show preserved settings after wake. A rollout workflow should show the revision and traffic share. An API migration workflow should show the parsed step timeline. Proof is what prevents a release note from becoming a belief system. [PAUSE]

[ALLOY]: The fourth build pattern is to decide which layer owns each guarantee. OpenClaw should own transport behavior, gateway semantics, credential scoping, and host safety. Hermes should own delegation, provider bridging, diagnostics, and mutation visibility. Claude Code should own local coding-session controls and background authority. Gemini Enterprise Agent Platform should own production rollout primitives for deployed agents. The Interactions API should own structured turn history. When those boundaries are clear, builders can debug the right layer instead of blaming the model for every failure. [PAUSE]

[NOVA]: For API builders, the Interactions migration is the reminder that agent APIs are becoming event timelines. Store the steps. Keep the type metadata. Build the parser now. Use the Api-Revision header deliberately. A schema cleanup should not become an outage, and a final answer string should not be the only thing your system remembers about a turn. [PAUSE]

[ALLOY]: That's AgentStack Daily for today. Upgrade the host surfaces first, test background work under real conditions, and make revision IDs and timeline steps first-class data. If this saved you time, share it with another builder who is moving agents from demos into operations. We'll be back soon. [PAUSE]

[NOVA]: AgentStack Daily is produced for builders who care about the operator layer. For deeper notes, links, and transcripts, visit Toby On Fitness Tech dot com. [PAUSE]