Episode 59: Hermes Agent 0.15.x, Codex 0.135, Claude Code 2.1.157, Opus 4.8, Browser MCP, and Usage Telemetry

I'm Nova. This episode covers Hermes Agent 0.15, Codex 0.135, Claude Code on NPM Latest, Opus 4.8, and 4 Project Radar Items. I'm Alloy, and this is AgentStack Daily. Hermes V2026.5.28 and V2026.5.29 ship a full multi-agent Kanban surface with auto-decomposition, swarm topology, and work tree isolation. Codex sharpened its diagnostics with a Richard-Doctor command. Claude Code shipped dynamic workflows as a core structural feature through an Opus 4.8 release. And the Project Radar covers four tools that make the AgentStack queryable at the point where it used to be opaque, Chrome DevTools MCP for browser state, CodeGraph for call paths, Usage for cost telemetry, and HyperFrames for generated media. Let's get into the releases. Hermes Agent 0.15 is the biggest platform-level shift in this cycle, and it is worth understanding what the Kanban surface actually changes before calling it a feature announcement. Kanban becomes a full multi-agent work surface inside a tool that used to be mostly about running a single agent. Auto-decomposition splits complex tasks into smaller work items that individual agents can claim, work on, and complete independently. Swarm topology coordinates agent collectives so several agents can operate in parallel on related work without crashing into each other's edits. Scheduled tasks add time-based triggers alongside the existing event-driven model, which means a task can fire at a specific clock time rather than only when a human pushes a button or an event arrives. WorkTree per task execution isolates each piece of work in its own file system context, which eliminates the problem where two concurrent agent sessions overwrite the same files and produce a scrambled result. Per task model overrides let the operator assign a complex refactor and a cheaper one to a straightforward documentation pass without touching the global configuration. Those five capabilities together answer a real coordination problem that teams hit as soon as they try to run more than one agent on the same project simultaneously. Without durable assignment, isolated working trees, and typed task decomposition, parallel sessions accumulate contradictory edits, ghost files, and confusion about who made which change and when. With this release, teams get a chain of custody for every piece of parallel work, every task has an owner, a model assignment, an isolated work tree, and a completion record. That is what a real operations platform looks like for agent work. The codebase split improves cold start the large single module path was broken into smaller pieces, which makes startup faster and maintenance easier to reason about. Session underscore search became dramatically faster and free. That is not a cosmetic detail. When a team has dozens of stored sessions and hundreds of tools loaded, search needs to be cheap and fast. If finding an old session is slow and expensive, builders stop trying. Fast, free search removes that friction entirely and makes project memory something people actually use. Promptware defense is new and important in this release. It detects and resists prompt injection attempts that try to redirect agent behavior through user-supplied text, comments, file names, variable names, or chat messages that contain hidden instructions designed to override what the agent was actually asked to do. The follow-up releases fix the loopback dashboard reload loop that made the web interface cycle endlessly on authentication errors. Anyone who uses the dashboard regularly knows how much that disrupts a session. Docker insecure mode becomes an explicit opt-in rather than something inferred from the bind host, which is a healthier security posture by default. Plugin manifests now ship in both distribution formats, which means an installed Hermes can discover what Plugins are available automatically without requiring manual configuration or path guessing. Path resolution for bare MCP commands improves across those patch releases, markdown media delivery gets restored after some regressions in that path, and packaging published artifacts are cleaner overall. OpenClaw stays on its stable line this week while Hermes takes the main release stage. The latest tagged OpenClaw release establishes the current baseline for content boundary enforcement, codex app server recovery logic, provider catalog work, embedding provider improvements, DLLM thinking parameter configuration, durable channel delivery, and metadata cache optimization. Worth watching in beta form is the OpenClaw.28 line, which is working through app server recovery, subagent workspace separation, hook context isolation, timeout lock release behavior, stale restart avoidance, channel identity hardening, discord recovered tool warnings, delivery path improvements across Slack and Telegram, malformed callback rejection, provider expansion, and browser timeout validation. That work belongs in the stable track once beta clears, and the changelog nodes are worth reading even if you are not deploying beta builds just yet. Codex 0.135 is smaller than the Hermes release, but it lands on the surfaces that matter most when a local coding agent breaks in ways that are hard to explain without structured diagnostics. Codex Doctor gets the most important upgrade in this release. It now reports richer environment diagnostics covering Git state, terminal setup, app server status, and thread inventory across the running session. That may sound like a support utility, but it is actually a core daily use feature. The overwhelming majority of coding agent failures are environmental rather than model-based. The wrong shell helper version, a stale app server process, a mismatched remote transport session, surprising repository state, or a terminal corrupting output, all of those look like agent failures until the Doctor command shows what the runtime environment actually looks like right now. Running Doctor before blaming a model is the first habit to build for anyone troubleshooting codex setups. Remote status reporting deepens for distributed setups. When the TUI is connected over a remote transport, the status command now surfaces connection details and server version alongside the basic output. That makes it practical to diagnose a misbehaving remote session without needing direct log access to the remote machine. For teams where the coding agent runs on a different host than the human, that operational visibility is a meaningful improvement over blindly guessing what version is running on the other end of the connection. Permissions management gets named profiles. Rather than one flat permission set assembled from scratch each time, a builder can define a profile with a specific name and a curated set of allowed operations and apply it to a specific context. A daily personal coding session might use a broad profile. A shared build environment or a repository with high blast radius commands gets a tighter one. Named profiles make the permission model auditable, reviewable, and assignable rather than a pile of one-off flags that are easy to forget and hard to reason about after the fact. Packaged builds can now discover the bundled patched ZSH helper across supported macOS and Linux targets. Codex on those platforms often runs command wrappers through the shell. If the helper version is wrong or unpatched, the wrapper produces unexpected behavior that looks like a command failure but is actually a shell integration problem. Making this discoverable and visible means doctor output and user diagnostics can report shell environment state accurately instead of guessing, which removes a whole class of misleading error messages that slow down debugging. The Python SDK adds opinionated sandbox presets for thread and turn APIs. Instead of configuring sandbox behavior from scratch on every new integration, teams can choose a preset that matches the intended interaction pattern. That is a safer, faster path for teams extending codecs without hand-rolling sandbox boundaries. The install process gains a non-interactive mode flag for CI pipelines, container image first-run sequences, and scripted environment provisioning, which makes automated setup practical for teams that want reproducible build environments. The fixes in this release are equally practical for daily use. Markdown tables and multiline lists render more readably. TUI output is more stable on macOS and Zellage. Slash command completion preserves draft text instead of clearing it prematurely, which is a small quality-of-life issue that becomes genuinely annoying in long interactive sessions. Older TMUCs and iTerm control mode sessions handle CTRL-C correctly again. Extension tools surface errors more clearly so developers see what failed rather than a generic failure surface. Remote attachments attach to the correct session without drifting. AppServer runtime now respects model choices on restart instead of silently overriding them. And MCP tools that have already disconnected stop showing as active when they have timed out, which removes misleading process state from the interface. The practical recommendation is to make CodexDoc the first diagnostic step before assuming the model is responsible for a failure. Define named permission profiles for any repository where broad shell operations would be risky. Use SDK sandbox presets instead of building configuration from scratch. Test one remote transport session after upgrading and compare the doctor output against what you would have found by manually running diagnostic commands. That sequence turns a vague failure into a specific failure with a named surface, a status readout, and a path to a recovery step. Claude Code on NPM latest moved through an Opus 4.8 release wave with several intermediate patches in the 2.1 line. The first notable landing brings Opus 4.8, dynamic workflows for longer background efforts, fast mode pricing adjustments, effort label changes, background shell dispatch from the agent's command, streaming tool execution by default, STIO MCP session environment variables, and pending approval rendering for MCP JSON server configurations. Dynamic workflows are the structural change worth understanding carefully. They let Claude Code organize larger efforts across background agents with workflow status reporting instead of making one foreground turn carry a long-running job to completion. That is the difference between an agent that handles a task in a single pass and an agent that can manage a multi-hour task with name checkpoints, status updates, and mid-process human approval points. Teams running large ref actors, test suite overhauls, multi-file migrations, or long documentation passes should find dynamic workflows change how long agent work feels in daily practice. Background shell dispatch through the agent's command adds a path for launching shell commands in the background without blocking the foreground session. Streaming tool execution means the agent surface shows progress as it happens rather than waiting to produce a final report after a long wait. Both together make long-running workloads more interactive and easier to monitor live rather than staring at a blank terminal wondering what is happening. A point release in that line patches a thinking block API error that affected Opus 4.8 sessions. That kind of targeted fix matters because Opus 4.8 puts heavier load on the reasoning and thinking infrastructure than earlier models. A thinking block API error can make a session look like a model failure when the model is perfectly fine and the problem is purely in how thinking output is transmitted by the transport layer during a long session. These patches are exactly why pinning to a working NPM version and actually reading changelogs matters for stability. The latest NPM release then ships the fuller plugin and worktree story. Plugins in the .clawed skills directory are now loaded automatically without manual registration. The plugin init command scaffolds a new plugin with the right configuration structure, removing the blank page problem for teams that want to extend Claude code. Plugin autocomplete improves so available commands are actually discoverable. The agent's command honors the agent field from the settings JSON file for dispatched sessions, which means an operator can configure which agent mode applies per task without changing how the CLI is invoked. Worktree switching becomes a named function rather than a separate utility call. Tool decision telemetry can optionally include full tool parameters when the user opts in. And completed worktrees are left unlocked so automated cleanup can prune them without hitting file locks, which is the kind of practical behavior that matters as worktrees accumulate across a team's workflow. That whole feature set turns plugins and worktrees into a first-class operational layer rather than features that work in simple cases and fall apart in complex ones. With automatic discovery, scaffolding, autocomplete, per task agent mode configuration, named worktree switching, optional telemetry detail, and clean unlock behavior on completion, the system is building a proper agent operating environment instead of bolting features onto a CLI. The distinction matters because the workflow layer is becoming as operationally important as the model underneath. Anthropic Opus 4.8 is the model underneath this wave. It is positioned for harder coding tasks, agentic workflows, and professional work, with standard Opus pricing unchanged from its predecessor while offering lower-cost fast mode than earlier iterations. The practical evaluation question is not whether a benchmark moved. It is whether the combination of stronger reasoning, effort controls, and the dynamic workflow layer can run a harder task end-to-end, produce clean worktree output, and hand-off results without the operator needing to babysit the session. Watch for how effort settings interact with the workflow layer on hard tasks, because that is where the value of Opus 4.8 shows up differently than in simple benchmark comparisons. The post-upgrade checklist should be specific and actionable. Pin the desired NPM lane to match the feature level the team actually needs. Test Opus 4.8 on one contained repository task to verify capability and API behavior. Create one local plugin using plugin init as a structural exercise to understand the layout. Verify that skills directory autoloading works as expected before the next session. Inspect whether completed work trees are being cleanly unlocked or accumulating as locked orphan directories that no automated cleanup can touch. Pinning the NPM lane is the most important of these steps because NPM latest moves faster than most teams track, and a team on an older 2.1 release may not realize what features it is missing from the newer line. OpenAI's May workspace agent release notes point at the same direction across several features. Agents are becoming shared workspace actors, not just personal assistants queried in isolation. The feature set is broad in scope. Workspace agents can use the latest GPT model with reasoning effort controls, which gives builders a way to tune reasoning investment per task. Admins can control which roles are permitted to publish agents into a shared directory, which means governance surfaces need to be set up front rather than retrofitted after something goes wrong. Dyated Setup walks users through agent configuration with better structured questions that reduce the chance of a misconfigured agent appearing in shared channels. Agents can produce audio files as output, which introduces storage, review, and distribution considerations that do not exist for text-only agents. Slack agents can respond to relevant follow-up messages in a thread after the initial mention, which means the agent needs enough context awareness to distinguish relevant replies from noise. App action safeguards let builders constrain what an agent can do within each enabled workspace application before the agent gets right-capable tools turned on. Those details matter because shared agents carry different risk profiles than personal ones. A Slack thread agent that does not know when to stay quiet will spam a channel with irrelevant responses. A speech output agent without storage and review policies will create audit problems. A shared directory without publishing permissions is effectively open to anyone who can discover it. App safeguards need to be set before mutating tools are enabled, not patched together after a problem appears. The OpenAI broader remote access and access token story fits the same architectural pattern. The machine that holds the files, credentials, and build outputs is the real execution boundary. Phones, scripts, and managed workspace identity become control surfaces that supervise what runs near the real environment. Execution stays near the private context where it belongs. Supervision and approval happen from the channel that fits the moment. That is the stable architecture for agent work in shared environments, run near the data, supervise from anywhere appropriate, keep identity scoped, and govern what the agent can publish and act on. The evaluation workflow for this release is short and concrete. Separate personal agents from shared directory agents and apply different trust levels to each category. Test Slack thread follow-up behavior in one low-risk channel before enabling broad threading. Set app-level action safeguards before the agent gets mutating tools activated. Keep audio file generation on explicit controlled workflows until storage, review, and distribution expectations are documented and understood. The policy layer is not a bureaucratic step that comes after deployment. For shared agent systems running in shared environments, it is the actual product. Once agents can respond in shared channels and take actions inside workspace applications, the admin surface becomes a core product layer rather than an afterthought. That is a meaningful shift in how agent deployment is understood across the industry, and it changes what every builder needs to think about when moving from personal agent experiments to shared team infrastructure. Chrome DevTools MCP is worth watching carefully because it addresses the most common front-end coding agent failure pattern. The model reads the source files, produces a confident edit, and the browser does something completely different at runtime that nobody predicted. The current release is a minor patch, but the project itself is the important piece with a clear purpose in the agent stack. Chrome DevTools MCP exposes Chrome browser debugging capabilities through an MCP bridge, which means coding agents can query and interact with a live browser through a structured interface instead of relying on screenshots, static source analysis, or copying console output manually. That distinction matters enormously for front-end work, where the gap between what the code does and what the browser actually does at runtime is the most common source of mysterious bugs. A DevTools-backed MCP bridge makes that gap visible and actionable instead of leaving the agent to guess from source. For OpenClaw, Codex, ClaudeCode, and Hermes, the value proposition is a tighter feedback loop from browser state into the agent reasoning layer. DOM inspection, network request monitoring, console output, runtime performance data, and page state all become queryable by the agent as structured, actionable information. This is fundamentally different from visual computer use, which shows what a human sees on screen but cannot explain why the browser reached that state internally or what conditions produced the current outcome. A screenshot tells you the effect. DevTools state tells you the cause. For the agent, that distinction changes how bugs get diagnosed. Rather than proposing a fix based on plausibility and hoping it works, the agent can reproduce the failure, query the specific console error or network code, check what the DOM actually contained at the moment of failure, and propose a patch backed by that evidence. A model that reads source files carefully can still miss runtime behavior that only appears in a running application. A network request that fails after hydration. A console error that surfaces after an asynchronous operation completes. A CSS rule overridden by a later stylesheet load where the timing makes the override difficult to predict. A page identifier that changes under specific user interaction sequences. A performance regression visible only under production load. All of these runtime behaviors are invisible to static source analysis no matter how thorough the reading, and they are fundamentally unpredictable from source code alone. This is why front-end agent work without browser instrumentation so frequently produces fixes that solve the wrong problem. The evaluation workflow is also the most practical use case. Connect Chrome DevTools MCP to one local front-end project. Reproduce a runtime bug through the browser while the agent observes the live state. Inspect console errors and network failures through the structured MCP interface. Then, and only then, ask the coding agent to propose a fix backed by the specific browser evidence. A front-end agent that can examine the running application output is far less likely to produce confident but wrong edits based on source analysis alone. This is the evidence first pattern applied to front-end work, and it produces better outcomes than trusting that the model understood the source correctly and hoping the next edit is right. The feedback loop is straightforward, reproduce the runtime failure, instrument the browser state with structured diagnostics, patch from that evidence, verify the fix in the browser, then document the cause and the solution for future reference. That loop is more reliable than trusting that the next model edit is correct and hoping a regression suite catches whatever the mistake turns out to be. The project radar has four surfaces today, each making a different dimension of the stack queryable instead of opaque. CodeGraph gives coding agents a local pre-indexed code knowledge graph so routing, call path, and architecture questions get structured answers instead of requiring the agent to spend tool calls visiting generated files and same name symbols. Its latest release improves go-GRPC implementation resolution so generated service stubs and handwritten service definitions are disambiguated correctly. Generated files get deprioritized in query results so agents see handwritten source first. Dynamic dispatch trace output now includes the full call chain for routing questions. Multi-module endpoint selection improves for larger projects, and small projects get inline routing context for simple route tables. That tracking specificity is what separates a code graph from a keyword search, not just what files contain a word, but how the architecture actually connects. The practical test for code graph is a routing question. Ask it how one web request reaches its handler through a layered service. Get a structured answer that traces the call path with evidence including file names, line numbers, and relationship types. Compare that with what raw text search would produce for the same question. If the structured answer actually changes the plan or reveals something text search would miss, code graph is earning its place in the stack. If the answer is no different from grep, it is not worth adding yet. Usage attacks a different blind spot, usage accounting and cost visibility at the operator level. Its current release adds Opus 4.8 pricing, fallback pricing behavior for unknown models, missing price warnings, co-pilot open telemetry gap explanations, and open code cost fixes. As agent stacks scale with more background workflows, long running sessions, model routing, and media generation, cost visibility becomes scheduler input rather than optional accounting trivia. A system that knows which models are running, what they cost per token, where the pricing table has gaps, and which telemetry paths are incomplete can route work to cheaper models when appropriate, pause before a budget window closes, or stop a task that has become wasteful. The cheapest failure is the one the scheduler avoids because it understood the budget before clicking upload or spawning 20 parallel agents. Cusage makes cost evidence available locally without requiring a third-party billing dashboard or waiting for a monthly invoice. Run it over current Claude code, codex, co-pilot, or open code sessions. Compare model families across similar tasks. Feed the observed usage into scheduler decisions before launching bulk agent work or media generation jobs. Without that, teams discover budget limits only when a job fails from running over a quota that nobody tracked. With it, the scheduler has input that actually changes behavior before the problem becomes a failure. Hyperframes is the media counterpart, treating video as HTML source plus renderable runtime so the output is testable, patchable, and version controllable rather than an opaque final artifact. The stack angle is bigger than individual playback fixes in a patch, HTML, CSS, animation state, playback rate, and rendered output all become software artifacts that coding agents can inspect and patch the same way they handle a source file. Agents can generate a visual sequence, render it, inspect playback behavior, patch from evidence, and keep the HTML source and version control alongside the script that produced it. That is more reliable than treating a final video file as the first real artifact and hoping the quality was acceptable without any inspection path. Hyperframes is practical for product demos, podcast shorts, documentation walkthrofs, and explainer clips. An agent builds a scene in HTML, renders it locally, verifies correctness, and patches from evidence the same way it would investigate a source file with a bug. The design panel and playback rate clamping changes in the latest release make the rendering pipeline more deterministic for CI and automated render jobs, which is what turns a one-off media experiment into a repeatable part of the workflow. Build a 20-second product explainer from HTML, render it locally, verify the visual output before uploading anywhere, then confirm the generated artifact looks correct before handing it off to a human reviewer. The fourth project is Clawd MEM, a persistent context layer for cross-session memory that works across multiple agent surfaces including Clawd Code, OpenClaw, Codex, Gemini, Hermes, Copilot, and OpenCode. Its latest release adds base URL configuration for flexible endpoint setups, spawn contract fixes and worker lifecycle hardening for more reliable background operation, output fidelity improvements for better context compression, and SQLite repair enhancements that help the persistent store recover gracefully from interrupted writes or bad state. For teams running more than one agent type against the same repository, Clawd MEM provides a practical shared memory surface. Several agents can query the same context store without each having to rediscover the same project information from scratch. The memory provider is explicit rather than tied to one agent's transcript format, which means teams can switch which agent handles a task without losing accumulated context. The practical validation is specific, connect to a disposable test repository, run two short sessions with different clients, and verify what context was recalled and what was withheld. That confidence in memory fidelity is what makes cross-agent handoff genuinely practical for real workflows. The common thread across all four projects is structured, queryable state where the stack used to be blind. Code graph answers call structure and routing questions. Usage answers cost and usage questions. Hyperframes answers rendered media questions. Cloud MEM answers cross-session memory questions. Implement the ones that close the biggest visibility gap in the current stack, not all of them simultaneously. A team whose agents frequently ask routing and architecture questions should add code graph first. A team whose scheduler tasks run over budget without warning should add Qsage first. A team whose agents generate media without good inspection paths should add hyperframes first. A team whose agents work in silos without shared context should add Claude MEM first. Match the project to the actual opacity problem, not to the most exciting star count on GitHub. The useful builder pattern here is evidence before action. If the build target is a front-end, the workflow should not begin with a competent patch. It should begin by opening the app, reproducing the behavior, reading the console, checking the network path, and then changing the smallest thing that explains the runtime evidence. Chrome DevTools MCP fits that workflow because it gives the agent a way to see the browser as a running system instead of a source tree that might or might not match what the user experiences. If the build target is a service or framework change, the workflow is different. The right starting point is the call path. Code graph is useful when the builder needs to know which handler receives a request, which service owns the domain transition, and which generated boundary should be ignored during planning. That is how an agent avoids a common failure mode, editing the first symbol that matches a search term, then discovering that the real path used a different implementation. The better pattern is to trace, patch, test, and only then ship. If the build target is a scheduled agent run, usage telemetry belongs near the front of the workflow. Background agents, media renders, translation lanes, and upload jobs can all be individually sensible while the combined run is too expensive or too close to quota. Usage does not replace provider limits, but it gives the builder a local cost signal before the scheduler starts work. A scheduler that knows the cost profile can choose a cheaper model for simple cleanup, reserve a stronger model for high-risk synthesis, delay a bulk job until the next quota window, or stop a deploy from launching more work than the day can absorb. If the build target is generated media, Hyperframes points to the same discipline. Treat the scene as code-shaped source, render it, inspect the result, patch what failed, and keep the build path repeatable. That workflow matters for demos, shorts, explainers, and product walkthrofts because the final media artifact should not be the first place anyone discovers that timing, layout, or playback state was wrong. A media pipeline that can be rendered and verified by an agent is much easier to maintain than a one-off export that only exists as a finished clip. And if the build target is cross-session agent continuity, CloudMEM is about trust boundaries as much as memory. The pattern is not simply remember more. The pattern is to decide what should be recalled, what should stay out of context, and how a builder proves that the memory layer behaved correctly across two different clients. That means testing recall against a disposable repository, checking what context returns, checking what context is withheld, and only then relying on it for a real multi-agent workflow. Put together, the radar is a set of workflow gates. Browser evidence guides front-end patches. Codeflow evidence guides architecture patches. Cost evidence shapes bulk agent dispatch. Render evidence shapes media release. Recall evidence shapes shared memory trust. That is the practical part of the episode. Each tool earns its place when it changes the next build decision, not when it adds one more logo to the stack. This is also how teams should evaluate releases like Hermes, Codex, and CloudCode this week. Do not ask whether the feature list sounds impressive in isolation. Ask which workflow becomes safer or faster. Hermes Kanban matters if tasks can be decomposed, assigned, isolated, retried, and audited. Codex Doctor matters if a broken local run can be diagnosed from environment state instead of guesswork. Cloud Code dynamic workflows matter if a long job can report status, keep its work tree clean, and hand back a result that the builder can actually review. The strongest release is the one that turns a confusing daily build path into a repeatable operating pattern. The practical queue from EP059 is not abstract. It maps directly to decisions a builder or team lead needs to make this week, and in some cases before the end of the day. For teams already running Hermes, the 0.15 upgrade is the most consequential platform decision on the table. The Kanban orchestration changes how parallel agent work gets split, assigned, and tracked. WorkTriper task execution makes that splitting safe because isolation is what stops two agents from writing to the same file simultaneously and producing a result that nobody can untangle. Scheduled tasks complete the story by letting the system fire work at a clock time rather than waiting for a human to be present at the terminal. Promptware defense, Bitwarden backed key management, the MCP catalog picker, and NTFY messaging are all significant capability additions layered on top of that orchestration core. For Codex users, 0.135 is the release that makes the runtime legible when something goes wrong. CodexDoctor with its richer environment, Git, Terminal, and Thread Inventory output is the first tool to reach for before filing a bug report, before assuming the model performance is the root cause, and before spending an hour manually inspecting the environment piece by piece. Named permission profiles solve a real permission management problem that most teams have been working around rather than solving. The non-interactive install path makes automated setup practical for CI pipelines and container environments for the first time. For Claude code teams, the NPM lane is moving fast and the gap between minor versions is widening in ways that affect features, not just reliability. The post-upgrade checklist should be a living document, which NPM distag is pinned, what the Opus 4.8 evaluation showed on one contained task, which plugins are loaded from the skills directory without manual registration, whether completed work trees are being cleanly pruned, and whether dynamic workflow tracking is being used for any long-running task. Pinning the NPM lane is the single most actionable step because it prevents a team from accidentally inheriting a breaking change from the latest tag without warning. For shared workspace agent deployments, the policy layer is the primary product now, not the agent itself. App safeguards, Slack thread guardrails, reasoning effort controls, and shared directory publishing permissions are what determine whether a workspace agent is actually safe to operate in a shared channel. That reframe is practical, and the teams that treat it as such will have fewer incidents and better outcomes for the humans who share those channels. Chrome DevTools MCP, CodeGraph, Qsage, and HyperFrames make up the tool layer that makes the stack inspectable. Each one answers a question the current stack guesses at. Try Chrome DevTools MCP on one local front-end bug reproduction before assuming the model understands the runtime. Add CodeGraph when text search keeps giving wrong answers about call paths. Run Qsage over local agent sessions to see what the budget actually looks like before scheduling bulk work. Use HyperFrames for one repeatable media task where the HTML source should stay in version control alongside the script that generated it. The best agent stack is not the one running the most concurrent agents. It is the one where each agent can see the runtime, understand the code path, know the budget, and leave evidence behind for the next session. That stack gets built one release at a time, one tool layer at a time, and one concrete workflow at a time. Start with the one that creates the most opacity in the current setup. For source links and episode notes, visit tobyonfitnesstech.com. I'm Nova. I'm Alloy, and this is Agent Stack Daily. We'll be back soon.