Episode 50: AgentStack Daily EP050 — What's New in Agent Releases

I'm Nova, and this is OpenClaw Daily. The old name was OpenClaw Daily, and the change matters. OpenClaw is still the operator runtime at the center of the show, but talking about one tool in isolation misses where the market is going. Hermes is becoming too capable and too popular to treat as a side note, and the same is true for the coding agents, app frameworks, and repository platforms around it. So AgentStack Daily means a daily tour of the agent stack, what changed, what each tool is for, and what a builder can actually use. Today that means Hermes Agent v2026.5.7, Claude Code v2.1.141 and the recent builds behind it, Google's ADK guidance for agents that pause and resume, and GitHub co-pilot agent tasks exposed through REST. I'm Alloy. That rename is not cosmetic. It is a better description of the work. OpenClaw is the operator runtime. Hermes is the board for delegated agent work. Claude Code and Codex are coding agent lanes near the repo. Google ADK is for stateful app agents. GitHub co-pilot agent tasks are cloud-hosted coding jobs with API status. If you only follow one of those in isolation, you miss the way agent products are being assembled in practice. Now the news, Hermes adds board durability, worker health checks, checkpoint management, gateway resume, deterministic cron checks, provider plugins, platform policy, and MCP repairs. Claude Code adds a better view of running agents, richer hook output, plugin source controls, workload identity scoping, MCP stability, and background agent permission fixes. So the structure is simple. First, a plain English map of what each tool is for. Then the what's new readout, Hermes v2026.5.7, Claude Code v2.1.141 through v2.1.129, Google ADK's stateful resume model, and GitHub's co-pilot task endpoints. The emphasis is product deltas, new surfaces, new controls, limits, risks, and the next checks to run. Start with OpenClaw because it explains the runtime surface behind the rest of the episode, channels, tools, browser actions, local commands, memory, media, background jobs, and proof back to a human. Hermes agent and Claude Code carry the release news today, but OpenClaw is the baseline that makes the agent stack feel like an operating layer rather than a loose set of chats. Quick tool map before the release details. OpenClaw is the operator and runtime layer. It is where channel messages, tool calls, browser control, local commands, media generation, background jobs, memory, and proof of work come together. Its value add is not just answering a prompt. It is letting an agent act through real interfaces, keep track of the work, and report back with evidence that a job actually ran. Hermes agent is the multi-agent board layer. Think of it as delegation, task state, handoff history, durability, and worker health in a visible board. Its value add is coordination across multiple agents or workers without making every status update live only inside a chat transcript. When Hermes gets better at cards, checkpoints, heartbeats, and resume, the system gets better at showing what is owned, what is blocked, and what can safely continue. Claude Code is the terminal local coding agent. It lives close to a repository, shells, hooks, MCP servers, project settings, and background coding sessions. Its value add is that a developer can ask for a change, inspect status, enforce local policy through hooks, and keep the work near the code base. The recent Claude Code changes matter because local agent work needs visibility, permissions, extension controls, and tool server reliability. OpenAI Codex is the repo-focused coding and review lane in this stack of tools. It is useful when the job is patching code, reading a repository, proposing a diff, reviewing a change, or reasoning through tests. There is no new Codex release selected for today's episode, but it remains part of the broader agent tooling picture. A coding agent should produce reviewable changes, not just a persuasive explanation. Google ADK is an application framework for agents that may run longer than a single chat turn. Its value add is structure, sessions, state, tools, storage, and resume points for agents that wait on approvals, webhooks, or outside events. GitHub co-pilot agent tasks are different again. GitHub-hosted async coding tasks with repository context, status, branch or pull request artifacts, and API access. Together, these tools show the agent market getting more concrete, runtimes, boards, local coding, app state, and repo-native cloud tasks. Hermes V2026.5.7 is a dense operator release. The short version is that the board is becoming less fragile. Multi-agent Kanban gets more practical because task ownership is visible, workers can heart beat, stale work can be reclaimed, and dead local processes can be detected instead of silently holding a card forever. That sounds unglamorous until you have watched a delegated run fail because one worker vanished and the rest of the board still looked optimistic. The slash goal update is also part of that durability story. A goal gives the session a named completion target instead of relying on the latest chat turn as the only source of truth. In release notes terms, the feature is small. In actual use, it is important because a long agent run needs something stable to optimize around, finish the verified change log, complete the test summary, prepare the support response, or collect the evidence package. The new feature makes that target visible to the system rather than merely implied by pros. Checkpoints V2 is the persistence update to watch. The release notes point to checkpoint pruning, storage guardrails, and safer resume semantics. In practical terms, a durable agent board needs saved state that is useful, not an ever-growing junk drawer. If a gateway restarts, a worker crashes, or a session resumes after interruption, the checkpoint should help the run continue with current context, not reload a pile of stale notes and partial task copies. That is the difference between persistence as a feature and persistence as a liability. Gateway auto-resume is the related runtime feature. Agent systems increasingly run behind a service boundary, a local gateway, a hosted gateway, a channel adapter, or a background scheduler. When that layer restarts, user-facing work should not disappear just because the process reloaded. Hermes V2026.5.7 moves more of that state into restart-aware behavior. The thing to test after upgrading is not just whether the command starts. Test what happens when the gateway restarts during an active run, when a checkpoint exists, and when a worker reconnects late. The release also adds more room for deterministic automation with no underscore agent cron. That is a very healthy feature. Not every scheduled check needs model judgment. A feed validator, disk space report, build health ping, or canary script may need reliable execution and a clear notification, not generated commentary. The new capability lets a board or scheduler run a plane check where plane checking is better. Mature agent platforms do not use models everywhere. They make it easier to use models only where judgment is actually needed. Security and platform policy are another big chunk of the Hermes release. The nodes call-out platform allow lists across chat surfaces, role policy details, WhatsApp stranger rejection, redaction defaults, and guild-scoped Discord behavior. These are not secondary features. They answer the question every production operator eventually asks, who is allowed to trigger work, from which channel, with which permission, and with what data protection. A useful agent that accepts the wrong trigger is not useful. It is an incident waiting to happen. Provider plugins and MCP repairs round out the Hermes update. Provider plugins make model and service integration more modular. MCP fixes around reconnect behavior, stale pipes, SSE transport, OAuth forwarding, keepalives, and image result handling matter because agent runs rarely stay inside a single process. They call tools, hit servers, wait on streams, and cross-auth boundaries. The release signal is clear, the ecosystem is moving from demos to integration maintenance. Boring transport fixes are exactly what make a product feel solid. Cloud code V2.1.141 through V2.1.129 is the second release thread. The new Cloud agents view is the easiest feature to explain and probably one of the first people will notice. It gives a visible list of agent sessions and their status. The CWD filter narrows that view to a project directory. If a developer machine has several background tasks, that small addition turns confusion into inspectable state, what is running, what is blocked, what finished, and what belongs to this repository. Hooks get a meaningful update too. Hook JSON can now include a terminal sequence, direct arges, and cleaner continuation behavior when a tool is blocked. That sounds like extension plumbing, but it gives teams a stronger contract between policy and user feedback. A hook can signal the terminal, pass structured arguments, block a dangerous operation, or let an expected block continue with better information. If you rely on hooks for security, formatting, project policy, or notifications, this is a release to test carefully. Cloud code also adds plugin and source control improvements. The changelog includes plugin source controls, HTTPS source cloning, managed setting migration details, cloud underscore project underscore DIR propagation, and anthropic underscore workspace underscore ID scoping. Those are enterprise-shaped features. They matter when a team does not want every project inventing its own plugin policy or identity boundary. After upgrading, test plugin installation, managed settings, identity scoping, and the behavior of hooks that depend on the project directory. MCP stability shows up again on the Claude side. Preserving MCP servers after a clear, improving concurrent OAuth refresh, and smoothing reconnect behavior all reduce the chances that an agent looks awake while its tool server is dead. This is one of the recurring messages in today's release news. Observability is not just a dashboard. It is the ability to tell when a session, a server, a token, a transport, or a background task is in a real state rather than a guest state. Background agent permission fixes are another practical change. If a background task inherits the current permission mode, that inheritance must be deliberate and predictable. A background agent should not silently become more powerful than the session that launched it, and it should not lose a permission it needs without a clear blocked state. Claude Code's recent versions keep tightening that behavior. If your team uses background agents, the upgrade test is permission mode, blocked tool UX, and whether the agent view accurately reports what happened. That gives us a concrete release checklist. Hermes V2026.5.7 Test board ownership Worker heartbeat Stale reclaim Checkpoint pruning Gateway resume Cron mode Allow lists Redaction Provider plugins And MCP reconnects Claude Code V2.1 1.141 Test the agent view CWD Hooks Plugion controls Workload identity MCP refresh Permission modes And background status Those are the updates you can act on this week. The next new item is Google's May 12th ADK article on long-running agents that pause, resume, and keep context. The useful part is not a magic prompt. It is a concrete state model. The guide shows a session with a current underscore step, explicit state updates through tool context.state, a session service backed by SQLite or Cloud SQL, and wake-up points that can be triggered by external events. That is the right direction for agents that cannot finish in one sitting. The feature problem is familiar. A model chat can remember the last few minutes of a conversation, but a real application may wait for a manager approval, a webhook, a form submission, a customer answer, or a payment event. If the agent tries to remember all of that by replaying an enormous transcript, cost goes up and reliability goes down. ADK's guidance is to persist the important state directly, the step, the required signal, the user data, the tool output, and the next safe action. Instruction interpolation is one of the practical details. Instead of asking the model to infer status from old messages, the app can put state values into instructions. The agent sees the current step, the known facts, and the allowed next action. That makes behavior easier to test. If current underscore step says waiting for approval, the model should not ship a final response. If the state says approval arrived, the next action can proceed. The feature is a guard against accidental amnesia and accidental overreach. Tool context.state is the right path. Tools can update persisted state as part of their normal execution. That matters because tools often know the truth better than the model. A payment tool knows whether the payment succeeded. A ticket tool knows whether a ticket is waiting on the customer. A database tool knows whether a row was updated. Writing that result into state gives the next turn a reliable source of truth instead of a narrated memory of what probably happened. The storage choice is also explicit. The tutorial references a database session service with SQLite for local development and Cloud SQL for more serious deployments. That may sound obvious, but it is a useful product signal. The agent state belongs in a service you can inspect, backup, migrate, and test. It should not be trapped only inside a transcript. Once the state is in a database, you can run evals, replay scenarios, simulate delays, and verify that resumed sessions do the right thing. Webhook Resume is the feature that makes the pattern feel real. An agent can pause, wait for an external signal, and resume when that signal arrives. The key is that resume should not mean, ask the model what it thinks was happening. Resume should mean, load the session state, read the event, check the allowed transition, and continue from a known step. That is how long-running agents avoid the classic failure mode where a delayed event causes the wrong action in the wrong context. The ADK guide also discusses sub-agent transfer and testing. The testing part deserves attention. Long-running agent bugs often hide in the gaps, after a delay, after a restart, after a tool failure, after a partial approval, or after a user changes their mind. Golden evals that precede state let teams test those gaps directly. You can start an eval with the session already halfway through the process, then check whether the next response is safe. That is a better test than only checking the happy path from the first user message. For builders following the release news, the takeaway is straightforward. ADK is pushing explicit persisted state as a first-class agent feature. Use short instructions, structured state, database-backed sessions, event-driven resume, and evals that cover delayed continuation. Do not let a production agent depend on a long chat log as its only memory. The new article gives a concrete template for moving from conversational memory to inspectable application state. It also pairs naturally with the Hermes and Claude code updates from the first segment. Hermes improves durable task tracking. Claude code improves local agent visibility. ADK improves application level state. Different products, same release error direction, less invisible magic, more inspectable state, more explicit permissions, more recovery after interruption, and better tests for the parts of agent behavior that used to be hidden. The third new item is GitHub Copilot Agent Tasks. GitHub's REST documentation exposes endpoints for starting and inspecting agent tasks by repository. The root shape is direct agent's repos, owner, forward slash, repo, tasks. The request can include a prompt, a model, a base ref, and whether to create a pull request. The task then moves through states such as queued, in progress, idle, waiting for user, failed, and completed. The important feature is not that Copilot can write code. We already knew that. The new value is that a coding task can become an API addressable repository object. Platform teams can start a task, store the task ID, inspect status, wait for artifacts, and gate the result through normal review. That makes agent coding easier to connect to issue triage, CI dashboards, release systems, and internal portals. It turns a chat instruction into a traceable repo operation. Permissions are central here. The docs reference fine-grained repository permissions for agent tasks. That means a system can grant task access without handing over broad repository control. The permission model is the feature to inspect before adoption. Which repositories can start tasks? Which actors can request a pull request? Which base refs are allowed? Which model can be selected? Which audit log entries appear when the task begins and when it produces an artifact? Those questions belong in the launch checklist. The create underscore pull underscore request option is also worth separating from the task itself. A task can investigate, change code, and produce an artifact. A pull request is the review boundary. Teams should keep that boundary visible. If a task creates a branch in PR, CI, code owners, protected branches, and normal review still apply. The new API surface is useful precisely because it can feed existing GitHub controls rather than bypass them. State polling is the other practical feature. A caller should not assume that a launched task is finished because the request returned. It should poll or subscribe according to the platform's supported pattern, handle waiting underscore for underscore user, handle failure, and record the artifact only after completion. This is where the agent task endpoint starts to look like any other async engineering job. Submit, persist ID, inspect status, process result, and record evidence. Model selection in the request is a small field with large implications. If a team can choose a model per task, policy needs to say which model is allowed for which repository and which data class. A documentation fix, dependency bump, security patch, and migration plan may not need the same model or the same context budget. The feature is powerful, but the governance should be boring, allowed models, allowed repositories, allowed base refs, and clear review gates. For release teams, the new copilot task API can become a clean way to queue repo work from another system. A failed test creates an issue. A trusted service starts an agent task against the repo. The task opens a branch or pull request. CI runs. Reviewers inspect the difference. The result lands through existing policy. That is a healthier pattern than pasting a giant prompt into a chat window and hoping the final answer maps cleanly back to GitHub. The limitation is also clear. Agent tasks are not a replacement for review, secrets policy, CI, or release approval. They are a new automation surface. Treat them like an API that can create work, not like an authority that can declare work done. The states in the docs are a reminder. Cued is not started. In progress is not safe. Idle may need attention. Waiting for user is not failure. And completed still needs artifact review. The best sign in this update is that agent coding is becoming normal platform infrastructure. It has endpoints, permissions, task states, branch behavior, and pull request options. That is what turns agent help from a one-off assistant into something a team can monitor. It also matches the broader trend in today's episode. State and visibility are becoming product features, not afterthoughts. If you are upgrading Hermes after V2026.5.7, start with the reliability features. Create a small test board. Confirm task ownership appears correctly. Kill a worker and verify stale reclaim or blocked state. Restart the gateway and verify resume behavior. Create enough checkpoints to observe pruning. Run a deterministic cron check with null model involved. Then test MCP calls across a reconnect and confirm redaction in logs. For clawed code, start with observability and hooks. Run clawed agents, then run it with CWD inside a project. Launch a background task and confirm permission mode. Trigger a hook that emits JSON and a terminal sequence. Test plugin source cloning over HTTPS. Clear a session and verify MCP server behavior. Check workload identity scoping with the relevant environment setting. The release is useful, but only if your local policy and tool servers survive the upgrade. For ADK, test delayed state. Build a tiny example with a session state value, a database session service, and an external resume event. Put the session into waiting state. Wait. Resume it with a simulated webhook. Then run an eval that starts from that waiting state without replaying the whole conversation. If that test passes, you have learned more than a polished demo would teach you. For Copilot Agent Tasks, test the API boundary before the coding result. Create a task in a non-critical repository. Store the task ID. Poll the state. Require a pull request instead of direct changes. Inspect the audit trail, permissions, selected model, base ref, and CI result. Then decide what categories of work are safe to submit through the endpoint. The new feature is promising, but the first win should be traceability, not speed. One thing to watch next is convergence around status vocabulary. Hermes has cards and workers. Cloud Code has agent sessions. ADK has persisted session state. GitHub has task states. The names differ, but the product direction is consistent. Users need to know what is running, what is waiting, what failed, what needs input, and what artifact was produced. Agent tools that cannot answer those questions will feel increasingly out of date. Another thing to watch is policy becoming a user-facing feature. Allow lists, role checks, permission modes, workload identity, plugion source policy, repository permissions, and model selection used to sound like admin details. Now they are part of the product story. The more capable an agent becomes, the more important it is to know who can start it, what it can touch, which provider it can use, and how its output is reviewed. The final trend is less romance about autonomy and more engineering around interruption. Heartbeats, reclaim, checkpoints, gateway resume, database state, webhook continuation, task polling, and blocked states are all ways of admitting that real systems pause, crash, wait, and recover. That is good news. Reliable products are built around failure modes, not around perfect demonstrations. Let's slow down on the Hermes details for a few more minutes, because the new release has several small features that will matter more in production than they do in a changelog skim. Worker heartbeat is the obvious one. A heartbeat turns silence into a measured signal. If the worker is alive, the board can keep waiting. If the heartbeat stops, the system can mark the task stale, reclaim it, or surface a blocked state. That is a basic reliability primitive, and it is exactly the kind of primitive agent products need. Stale reclaim is the companion feature. Without reclaim, a failed worker can leave a task looking owned forever. With reclaim, the board can decide that ownership has expired. The important detail is that reclaim should not pretend the previous attempts succeeded. It should preserve the failure mode, retry count, evidence, and last known state. Builders should inspect that behavior after the upgrade. A reclaim task should be auditable, not magically fresh. Zombie detection on Darwin sounds like a platform footnote, but it is another example of the same product direction. Local agent runs often depend on child processes, shell commands, browser processes, tool servers, audio generation, image generation, or test runners. If a process dies badly, the agent layer needs to know. Detecting zombie state is not exciting marketing copy. It is how a local automation product stops confusing process exists with work is healthy. Checkpoint pruning deserves a similar reading. Persistence that never prunes eventually becomes its own outage source. Disk fills up. Resume gets slow. Old state competes with current state. A checkpoint feature is only mature when it includes limits, cleanup, and clear failure behavior. After Hermes B2026.5.7, the smart test is to create several runs, interrupt one, resume one, and inspect the checkpoint directory or database entry for size, freshness, and recoverability. The provider plugin change is also bigger than it first appears. Agent products increasingly need to swap model providers, route specific tasks to specific APIs, and keep provider-specific options from leaking into the wrong backend. A plugin boundary lets that integration become more explicit. It also gives operators a place to test auth errors, request timeouts, fallback behavior, token limits, and provider-specific response formats without rewriting the rest of the product. MCP repair work is in the same category. Model context protocol servers can expose file search, issue search, browser actions, app APIs, or internal services. When the transport is SSE, when OAuth tokens refresh concurrently, or when a pipe goes stale, the agent may fail far from the original prompt. Hermes and Claude Code both shipping MCP stability updates in the same episode is a useful signal. The tool layer is becoming a first-class maintenance surface. On Claude Code, the agent view may become one of those features that feels obvious after it exists. Before it, a user could launch background work and then rely on memory, terminal scrollback, or external process checks. After it, the CLI itself can answer status questions. Running, blocked, completed, and project-scoped views are table stakes for serious local agent use. The command is simple, but the product implication is large, local agent work is becoming inspectable. The hook terminal sequence field is similarly practical. Terminal feedback is not just decoration. A hook may need to make a blocked action visible immediately, change a terminal title, ring a bell, or signal completion while the user is in another pane. Structured hook output gives teams a cleaner way to connect policy to feedback. The important test is whether hooks remain predictable across interactive sessions, background sessions, and blocked tool calls. Plugin source control matters for supply chain reasons. If a coding tool can load Plugins, then source policy is part of security. HTTPS cloning, managed settings, approved sources, and workspace identity are not glamorous, but they reduce ambiguity around where executable extension code came from. Teams should treat Plugin configuration like dependency configuration, known source, known version, known permission, and known update path. Workload identity scoping with Anthropic underscore workspace underscore ID points in the same direction. A local CLI may feel personal, but many users now run it inside company projects, managed environments, or shared dev boxes. Identity needs to follow the project boundary and policy boundary. If the wrong workspace ID leaks into the wrong project, billing, audit, and permission checks can all become messy. The new setting deserves a small but deliberate upgrade test. Google's ADK article is important because it makes a clean distinction between model context and application state. Model context is the text the model sees. Application state is the durable record the app owns. Long-running agents need both, but they should not confuse one for the other. The article's current underscore step example is simple on purpose. A small state value can prevent a large class of errors when the agent resumes after a delay. The database session service detail also tells builders where Google thinks this category is going. Local SQLite for development, Cloud SQL for more serious deployment, and state writes through tool calls, that is not a toy pattern. It is a normal application architecture with an AI layer added. The agent can still reason, write, and call tools, but the app owns the durable record. That makes debugging and compliance easier because the state can be inspected outside the model. Webhook-driven resume is the moment where the feature stops being theoretical. Imagine an approval arrives 12 hours later. The app should load the session, read the approval event, confirm the expected step, and continue. It should not ask the model to reconstruct the approval chain from old pros. The same idea applies to support cases, onboarding, finance approvals, device provisioning, and any task where time passes between request and response. Golden evals for delayed state are especially useful. Teams often test only the first request and the final answer. The bug is usually in the middle, after a timeout, after a partial tool result, after a user changes an answer, or after an external event arrives twice. Preceding state lets an eval start exactly in that middle condition. That turns a scary real-world edge case into a repeatable test case. It is one of the most valuable ideas in the ADK post. GitHub's Copilot Task API is important for a different reason. It makes agent coding fit a repository platform. The endpoint can create a task, attach it to a repo, select a model, choose a base ref, and optionally create a pull request. That lets another service treat Copilot work as an async job. The result can be observed through status, branch, and PR artifacts instead of disappearing into an assistant chat. The permission model is the first thing to study in the docs. Fine-grained repository permissions reduce the need for broad tokens. A platform can grant access to start agent tasks without granting every possible repo action. That is the right direction, but it still needs careful configuration. A task starting service should have a narrow token, a known repository set, a clear base ref policy, and a review requirement before changes land. The task states are just as important as the start endpoint. Cued means accepted, not finished. In progress means active, not safe. Idle may mean the agent is waiting or needs attention. Waiting for user is a product state, not a generic error. Completed means an artifact exists, not that the artifact is correct. Failed means the caller needs an error path that tells a human what happened. Those states give teams enough structure to build monitoring around agent coding. Pull request creation is the sensible artifact boundary. A branch and PR-led existing GitHub controls do their job, CI, review, code owners, checks, protected branches, and audit history. The new feature should make code work more traceable, not less. If a team adopts co-pilot tasks and bypasses review, it has missed the best part of the update. The API is most valuable when it plugs into the engineering controls that already exist. Put all four stories together and the news is not abstract. Hermes adds stronger durability for delegated work. Claude code adds stronger local visibility and extension controls. ADK adds explicit persisted state for delayed agents. GitHub adds API-addressable coding tasks with repo states and PR artifacts. That is a week of concrete product movement. It is not hype about agents replacing teams. It is tooling becoming more operational. The question for the next few releases is how much of this becomes standard vocabulary. Heartbeat, checkpoint, permission mode, persisted state, task status, model selection, provider plugin, MCP reconnect, pull request artifact, eval case, audit log. These are the words that make agent systems legible. The products that make those words easy to inspect will be the products teams trust. Here are the builder checks I would put beside the release notes. First, build a tiny health test for every new status feature. Four Hermes, that means a board with two tasks, one healthy worker, one interrupted worker, and a visible final state. Four clawed code, that means an agent session that is running, one that is blocked, and one that is completed. Four GitHub, that means a task that moves from queued to completed with a pull request. Four ADK, that means a delayed resume event that changes stored state. Second, build a permission test before a productivity test. A new agent feature is only safe if the boundary is clear. Test who can start it, which provider it can call, which repository it can touch, which token it uses, which model is allowed, and which action requires review. Builders often test the happy path first because it is exciting. Operators should test the boundary first because it is the part that prevents surprises. Third, build an evidence habit. Every useful agent product in today's episode is moving toward evidence. Fourth, build around failure modes. Interrupt a Hermes worker. Break an MCP server. Expire an OAuth token. Block a Claude Code hook. Send an ADK resume event out of order. Make a copilot task wait for user input. These are not destructive tests for their own sake. They are the tests that tell you whether the new feature can survive normal production messiness. A tool that only works in the demo path is not ready to own important work. Fifth, build the smallest useful use case before expanding. Four Hermes, a release note verification board is enough. Four clawed code, one project scoped agent view is enough. Four ADK, one approval gate with persisted state is enough. Four copilot tasks, one low-risk documentation PR is enough. Small tests reveal product behavior quickly. After that, the builder can add more users, more repositories, more tools, and more policy. These checks are not a detour from the news. They are how the news becomes useful. A release note says a feature exists. A builder check says whether it works in your environment. The gap between those two is where many agent products fail. Today's updates are promising because they expose more of that gap. Status, state, permission, retry, provider, transport, and artifact behavior are easier to see than they were a year ago. The other practical point is upgrade sequencing. Do not upgrade every moving part at once if you can avoid it. Start with the product whose new feature solves the most immediate problem. If your pain is invisible background work, start with clawed codes agent view. If your pain is delegated work getting stuck, start with Hermes. If your pain is delayed approvals, start with ADK state. If your pain is GIT hub-hosted code tasks, start with the copilot API. Builders get better data when one variable changes at a time. And if you maintain an internal platform, turn these into default templates. A Hermes board template with evidence fields. A clawed code hook test template. An ADK state eval template. A GitHub task submission template with repository permission checks. Templates make good behavior repeatable. The newest agent features are moving in that direction, less improvisation, more productized state, more inspectable artifacts, and clearer upgrade tests. One last builder note before the recap. Build a dashboard that says less but proves more. The builder view should show the active task, the blocked task, the last retry, the selected provider, the current permission, the latest artifact, and the next human decision. That is enough for an operator to act. A builder does not need a wall of generated pros when a concise status table, a link to a pull request, and a clear error state will do. A second builder note, build rollback into the adoption plan. If a new plugin source breaks off, if a provider adapter changes response schema, if an MCP transport starts timing out, or if a background agent inherits the wrong permission, the operator should know how to return to the previous config. The use case is not only shipping a new feature. The use case is shipping it with a safe exit. That is what turns an exciting release into a responsible upgrade. And a third builder note, build shared language into team reviews. Ask, what is the state, what is the artifact, what permission was used, what provider was called, what retry happened, and what evidence supports completion. Those questions work across Hermes, Claude Code, ADK, and Copilot tasks. They give builders a practical review habit that survives product differences. The best new agent features make those questions easier to answer. So the concise recap is this. Hermes Agent V2026.5.7 ships durability and operator safety features for delegated agent work. Claude Code V2.1.141 and the recent versions around it improve agent visibility, hooks, plugins, identity, MCP stability, and permissions. Google ADK shows how to store state for agents that pause and resume. GitHub Copilot agent tasks give repo automation a rest-addressable task surface. Those are the week's useful agent updates. If you only test one thing from each story, make it this, Hermes resume after interruption, Claude Code agent visibility plus hook behavior, ADK persisted state after a delay, Copilot task status plus pull request gating. Those tests line up with the core product movement. The new features are not just making agents more capable. They are making agent work easier to observe, recover, and govern. That's Agent Stack Daily for today. For show notes, source links, and transcripts, visit Toby on Fitnesstech.com. I'm Nova. And I'm Alloy. We'll be back soon.