Track important changes in Agent Orchestration Platforms, including capabilities, product updates, adoption signals, risks, and evidence worth continued monitoring.
Fixed a race in `cancel_run` where two concurrent cancel requests could both pass the pre-check and one call returned `409` after another had already interrupted the run; the API now re-checks state after `cancel()` fails and returns `202` when the run is already interrupted or already cleaned up.
What ChangedFixed a race in `cancel_run` where two concurrent cancel requests could both pass the pre-check and one call returned `409` after another had already interrupted the run; the API now re-checks state after `cancel()` fails and returns `202` when the run is already interrupted or already cleaned up.
Why It MattersOperators and integrations that send duplicate cancel requests (for retries, timeouts, or concurrent controllers) now get deterministic success instead of random `409` failures when a run was already interrupted, reducing false alarms and unnecessary re-cancel loops while keeping protection against canceling already finished work.
After a failed `cancel()` call, the gateway re-fetches the run state and maps `interrupted` or absent records to `202`, while preserving `409` for successful/completed runs.
Watch for clients that previously treated any `409` as a terminal cancel error, and monitor conflict-rate telemetry under high-concurrency cancellation storms to catch any remaining race regressions.
Final score 80Confidence 951 evidence itembytedance/deer-flowcancel_runrun statusinterruptedHTTP 202HTTP 404HTTP 409gateway cancel API
The PR adds end-to-end routing of watcher events from the agent dashboard into the matched conductor session’s tmux pane, by adding `RoutedTo` to `watcher.Event`, populating it in `engine.writerLoop`, and dispatching formatted events in `ui.Update` via `ui.dispatchWatcherEvent` instead of leaving them in the TUI only.
What ChangedThe PR adds end-to-end routing of watcher events from the agent dashboard into the matched conductor session’s tmux pane, by adding `RoutedTo` to `watcher.Event`, populating it in `engine.writerLoop`, and dispatching formatted events in `ui.Update` via `ui.dispatchWatcherEvent` instead of leaving them in the TUI only.
Why It MattersConductor operators and automation flows can now see matched watcher events inside the target conductor pane as they happen, so GitHub activity can trigger immediate Claude reactions instead of being silently missed after reaching the dashboard. This is achieved by propagating router matches into each watcher event (`RoutedTo`), pushing them onto `routedEventCh`, and dispatching to `ConductorSessionTitle(evt.RoutedTo)` using the same tmux path already used by health alerts. Watch for whether required source settings are fully wired (dependency on the separate GitHub source settings work) and for coverage gaps where exact human-author matching misses bot-driven events, since those remain unrouted.
Final score 80Confidence 941 evidence itemwatcher.EventRoutedTowriterLoopui.dispatchWatcherEventtmux send-keysroutedEventCh
This change adds Hermes as a built-in agent and introduces a shared configuration path so all six builtin agents (claude, gemini, opencode, copilot, codex, hermes) now honor a uniform `[tool].command` and `[tool].env_file` override model, while fixing a case where env_file values for opencode/codex/copilot were silently ignored.
What ChangedThis change adds Hermes as a built-in agent and introduces a shared configuration path so all six builtin agents (claude, gemini, opencode, copilot, codex, hermes) now honor a uniform `[tool].command` and `[tool].env_file` override model, while fixing a case where env_file values for opencode/codex/copilot were silently ignored.
Why It MattersOperators and developers using multiple built-in assistants can now configure startup commands and environment files consistently, so custom credentials and runtime flags are more likely to be applied correctly across agents instead of being silently ignored. This reduces broken tool sessions caused by missing env-based settings and shortens setup time when onboarding new agents, because Hermes now follows the same override pattern as existing builtins. The fix replaces the previous fallthrough path in env-file lookup and standardizes command building (`GetToolCommand`, dedicated builders), so behavior is predictable across six agents. Watch for command-precedence and tool-detection edge cases (especially Hermes binary matching/content patterns) that could still cause wrong process targeting under unusual local environments.
Final score 80Confidence 941 evidence itemagent-deckHermes Agentbuiltin agents[tool].command[tool].env_fileGetToolCommandgetToolEnvFile
This update makes GitHub Copilot CLI a first-class supported agent by adding official MCP plugin wiring and a dedicated connect path in agentmemory, enabling Copilot users to onboard with the same integration model already used by other coding agents instead of custom, error-prone setup.
What ChangedThis update makes GitHub Copilot CLI a first-class supported agent by adding official MCP plugin wiring and a dedicated connect path in agentmemory, enabling Copilot users to onboard with the same integration model already used by other coding agents instead of custom, error-prone setup.
Why It MattersDevelopers can now hook Copilot CLI into agentmemory with a supported setup path instead of ad-hoc config edits, so teams can capture Copilot tool events more consistently and reduce onboarding friction and config mistakes in local workflows. The change works by adding MCP-first plugin/install configuration plus idempotent CLI config merging and hook-field normalization, which should make Copilot integrations easier to operate across environments; watch for drift in Copilot event schemas, edge-case MCP-config merge conflicts when multiple servers are present, and Windows-specific command wrapping behavior that could reintroduce setup failures on some developer machines.
This change moves summon’s subagent/skill discovery out of initialization and into the per-turn McpClientTrait instruction path, so agents or recipes added to .agents/ or .goose/ during an active session are visible on the next reply.
What ChangedThis change moves summon’s subagent/skill discovery out of initialization and into the per-turn McpClientTrait instruction path, so agents or recipes added to .agents/ or .goose/ during an active session are visible on the next reply.
Why It MattersOperators and developers can add or modify .agents or .goose extensions in a running Goose session and use them on the next turn without restarting or recreating the session, which prevents workflow interruption during long-running tasks. This is achieved by moving listing from SummonClient::new and InitializeResult::instructions into McpClientTrait::get_instructions, which the system already calls via prepare_tools_and_prompt → get_extensions_info every turn; watch next for added per-turn overhead and consistency behavior when extension files change while inference is in progress.
Final score 78Confidence 961 evidence itemSummonClient::newMcpClientTrait::get_instructionsInitializeResult::instructionsprepare_tools_and_promptget_extensions_infoSummonClient.agents/.goose
The PR adds an explicit `skills/new` route and updates `SkillsView` to handle that path with `CreateSkillForm`, so “Create Skill” no longer falls through to `/skills/:skillId`; users without create permission are redirected to `/skills`.
What ChangedThe PR adds an explicit `skills/new` route and updates `SkillsView` to handle that path with `CreateSkillForm`, so “Create Skill” no longer falls through to `/skills/:skillId`; users without create permission are redirected to `/skills`.
Why It MattersAgents using the Create Skill path in LibreChat now land on the correct create form instead of the wrong skill detail view, which reduces user confusion and failed workflow setup when building or editing agents. This is achieved by making `/skills/new` a first-class client route and routing it to `CreateSkillForm` before the parametric `/skills/:skillId` path; continue to watch for regressions in route matching around other skill URLs and verify redirects still behave correctly for users with partial permission sets.
Final score 78Confidence 951 evidence itemLibreChatClient routesskills/newSkillsViewCreateSkillFormSKILLS.CREATE
This change introduces a new `crush acp` command that enables Crush to run as an ACP server, adding core session and prompt flow support (initialize/authenticate/new session/prompt/model switching) plus lifecycle translation for permissions, tool calls, plans, and notifications. It consolidates prior ACP attempts and aligns the branch with current `main` while exposing ACP-compatible built-in and custom prompt/tool commands.
What ChangedThis change introduces a new `crush acp` command that enables Crush to run as an ACP server, adding core session and prompt flow support (initialize/authenticate/new session/prompt/model switching) plus lifecycle translation for permissions, tool calls, plans, and notifications. It consolidates prior ACP attempts and aligns the branch with current `main` while exposing ACP-compatible built-in and custom prompt/tool commands.
Why It MattersDevelopers and operators can now connect ACP-compatible clients directly to Crush as a server, which should reduce custom adapter work and simplify multi-tool orchestration of prompts, permissions, and tool actions during agent workflows. Technically, the PR completes ACP interface coverage (`acp.Agent`, `acp.AgentLoader`, `acp.AgentExperimental`) and publishes unified command/tool/session events via the Sink path, but adopters should continue monitoring for missing embedded-context support, unsupported media inputs, session-mode behavior gaps, and hidden startup errors from suppressed `NewAgentSideConnection` failures as rollout progresses.
Final score 78Confidence 921 evidence itemCrushACPcrush acpacp.Agentacp.AgentLoaderSinkSessionNotification
The pull request adds one unified global settings experience (`brv settings` plus synchronized TUI and Web UI surfaces) backed by validated, persisted storage loaded at daemon startup, so operators can inspect and update runtime controls from a single control plane.
What ChangedThe pull request adds one unified global settings experience (`brv settings` plus synchronized TUI and Web UI surfaces) backed by validated, persisted storage loaded at daemon startup, so operators can inspect and update runtime controls from a single control plane.
Why It MattersOperators can now configure runtime limits and behavior from one place instead of hunting through separate CLI, TUI, and Web UI flows, which reduces mismatched settings usage and helps keep long-running local LLM jobs stable. The change adds startup-time validation and explicit restart-required handling to avoid silent invalid-config states, but it should be monitored for workflows that assume immediate hot-reload or need per-project overrides.
The PR rewires ByteRover skill installation to use a managed multi-file skill layout plus agent-aware install behavior, so global-only autonomous agents (Hermes/OpenClaw) can be installed without the old hardcoded project-scope assumption and with automatic BYTEROVER RULES insertion/removal in their system-prompt files.
What ChangedThe PR rewires ByteRover skill installation to use a managed multi-file skill layout plus agent-aware install behavior, so global-only autonomous agents (Hermes/OpenClaw) can be installed without the old hardcoded project-scope assumption and with automatic BYTEROVER RULES insertion/removal in their system-prompt files.
Why It MattersOperators can now install or refresh ByteRover for Hermes/OpenClaw without manual prompt patching or scope-related failures, so autonomous agents are less likely to lose the memory contract that governs their behavior after each install/uninstall cycle. Under the hood, install state is now idempotent and tied to marker-bounded prompt blocks (`<!-- BEGIN/END BYTEROVER RULES -->`), and hub install defaults to per-agent scope (global for global-only agents), which should reduce support noise around `project`-scope errors. Continue to watch for regressions in custom system prompts and environment-driven path resolution, because those are still the paths that can cause wrong placement or skipped attachment.
Final score 77Confidence 891 evidence itemByteRover skillHermesOpenClawHub installBYTEROVER RULESSKILL.md
Codeg now treats Grok as a native local ACP binary agent, registering it in the shared ACP registry and routing install/update/uninstall through the existing local binary cache path instead of a Grok-specific remote or resolver flow.
What ChangedCodeg now treats Grok as a native local ACP binary agent, registering it in the shared ACP registry and routing install/update/uninstall through the existing local binary cache path instead of a Grok-specific remote or resolver flow.
Why It MattersUsers who deploy Codeg can onboard and manage Grok using the same local ACP tooling as other agents, so Grok no longer requires a separate setup path and is easier to install and maintain through existing workflows. This also means new Grok sessions should behave more consistently with existing local-agent operations because registration, updates, and cleanup now share the shared ACP registry + binary-cache behavior. Continue to watch for platform-specific failures in raw executable downloads and any regressions in Grok session resume/transcript handling that could block first-time setup or reopened sessions.
This PR adds an optional `all_projects` boolean to `mem_search` so callers can request cross-project lookup, while keeping default behavior unchanged when the flag is omitted or set to false.
What ChangedThis PR adds an optional `all_projects` boolean to `mem_search` so callers can request cross-project lookup, while keeping default behavior unchanged when the flag is omitted or set to false.
Why It MattersDevelopers and operators can now retrieve memory search hits across multiple projects with a single `mem_search` call, so cross-project workflows no longer require repeated per-project queries or manual project switching; this is especially useful for debugging and agent operations that span project boundaries. The change is implemented in MCP request parsing and handler logic, which now routes `all_projects: true` to project-agnostic lookup while preserving existing scoped behavior for `false`/unset, so the next signal to watch is whether global results stay bounded by intended access controls and whether large multi-project queries introduce response latency or result-volume surprises.
Final score 77Confidence 961 evidence itemmem_searchall_projectsMCPhandleSearchproject resolution
ACP command discovery is refactored to return one merged command set (built-ins + recipes + skills) so clients use a single source of truth for slash-command availability, instead of separate paths for each command type.
What ChangedACP command discovery is refactored to return one merged command set (built-ins + recipes + skills) so clients use a single source of truth for slash-command availability, instead of separate paths for each command type.
Why It MattersClients and operators using ACP can now discover and invoke slash commands more reliably from a single unified list instead of treating built-ins, skills, and recipes as separate, inconsistent surfaces, which reduces user-visible failures when a command is present but not shown through one command surface. The implementation merges command sources in `available_commands_update` using builtin > recipe > skill precedence and aligns skill/recipe invocation behavior, but teams should monitor for stale command lists when skills/recipes change (or working directories switch), because the PR notes no robust event-driven refresh path yet and stale catalogs can still cause wrong or missing suggestions.
Final score 77Confidence 931 evidence itemACPavailable_commands_updateslash commandsskillsrecipesbuiltin commandsargument parsing
Overstory updated @os-eco/mulch-cli from 0.6.5 to 0.8.0, adopting the new non-destructive lifecycle behavior where `ml prune` now soft-archives stale records instead of deleting them.
What ChangedOverstory updated @os-eco/mulch-cli from 0.6.5 to 0.8.0, adopting the new non-destructive lifecycle behavior where `ml prune` now soft-archives stale records instead of deleting them.
Why It MattersOperators and developers using mulch now avoid irreversible cleanup losses during maintenance, because stale records are preserved in an archive instead of being removed outright and can be restored when needed. This is especially important for shared knowledge bases where over-pruning can remove useful context. Track archive growth and cleanup policy, and verify restore behavior in multi-domain setups where ambiguous IDs can still fail, so you know when recovery workflows become operational bottlenecks.
Final score 77Confidence 941 evidence item@os-eco/mulch-climl prunesoft archiveml restore.mulch/archive
PR #1226 is an analysis-only feasibility paper that commits Agor to a hybrid topology where execution runs on a local agent while the hosted daemon remains the canvas source of truth. It rejects a standalone local Electron-only product and P2P as non-starters, and defines a phased D1–D8 delivery path with the largest technical risk concentrated in offline reconnection and authentication/authorization for long-lived agents.
What ChangedPR #1226 is an analysis-only feasibility paper that commits Agor to a hybrid topology where execution runs on a local agent while the hosted daemon remains the canvas source of truth. It rejects a standalone local Electron-only product and P2P as non-starters, and defines a phased D1–D8 delivery path with the largest technical risk concentrated in offline reconnection and authentication/authorization for long-lived agents.
Why It MattersTeams that run Agor in collaborative environments now have a clearer path to keep worktrees local while still sharing a team canvas, which could unlock safer local development without forcing everyone onto a single remote execution mode. After this design, operators should watch whether the offline-buffer/reconnect work (D6), state conflict resolution (D7), and per-directive auth with fast revocation (D4) are implemented correctly, because these are the first gates that determine whether the plan is actually reliable in real-world use.
gentle-engram v0.1.6 updates startup behavior so Pi-launched/configured Engram processes with token+server settings automatically enable Engram core cloud autosync, reducing manual sync configuration for deployments.
What Changedgentle-engram v0.1.6 updates startup behavior so Pi-launched/configured Engram processes with token+server settings automatically enable Engram core cloud autosync, reducing manual sync configuration for deployments.
Why It MattersPi operators and teams running configured Engram processes will get cloud autosync enabled by default when credentials are present, so synchronized cloud state is more likely to be active immediately after launch instead of requiring manual toggling, which helps prevent drift or missed updates; watch whether intentionally disabled autosync environments and legacy MCP launcher paths still behave as expected. The implementation keeps ENGRAM_CLOUD_AUTOSYNC as a hard override and keeps project enrollment/pause enforcement in policy, and it migrates only known legacy generated Pi MCP launchers to avoid altering custom MCP configurations, so migration safety should be the next operational check.
The PR’s strongest concrete change is the bump of @github/copilot-sdk from 0.2.2 to 0.3.0, enabling Copilot session-level authentication and finer-grained per-agent control (including tool visibility/skill injection and sub-agent streaming metadata) for integrations that build multi-agent workflows.
What ChangedThe PR’s strongest concrete change is the bump of @github/copilot-sdk from 0.2.2 to 0.3.0, enabling Copilot session-level authentication and finer-grained per-agent control (including tool visibility/skill injection and sub-agent streaming metadata) for integrations that build multi-agent workflows.
Why It MattersDevelopers running AGOR-based agent orchestrations can separate credentials and permissions by session and by sub-agent, which helps prevent accidental cross-user actions, quota mixing, and tool misuse in multi-user or multi-agent automation flows. The practical follow-up is to watch for any session reuse paths or stream consumers that still assume one identity and root-agent-only event IDs, because the new model changes how identity, permissions, and streaming events are associated and could break existing assumptions during rollout.
Final score 75Confidence 871 evidence item@github/copilot-sdkAGORv0.3.0per-session authenticationagent-level tool visibility
Release v0.70.0 extends Crush retry behavior so temporary network issues (such as short disconnects or DNS failures) are retried automatically, instead of failing immediately when no specific HTTP error code is returned.
What ChangedRelease v0.70.0 extends Crush retry behavior so temporary network issues (such as short disconnects or DNS failures) are retried automatically, instead of failing immediately when no specific HTTP error code is returned.
Why It MattersUsers of Crush will experience fewer hard failures during brief network hiccups, so prompts and API calls are more likely to succeed without manual reruns or intervention. This is implemented by expanding the retry path from status-code-only conditions to include network exceptions, so operators should monitor for repeated side effects on non-idempotent operations, retry amplification during unstable links, and any increased upstream rate-limit pressure.
Final score 74Confidence 961 evidence itemCrushretry logicnetwork errorserror-code retries
The primary change in this PR is the async scheduler migration: `AsyncAgentScheduler` is introduced as the async-native path and wrapper context handling is rewired from global singletons to context-local resolution so multi-agent runs use a consistent runtime/tool context.
What ChangedThe primary change in this PR is the async scheduler migration: `AsyncAgentScheduler` is introduced as the async-native path and wrapper context handling is rewired from global singletons to context-local resolution so multi-agent runs use a consistent runtime/tool context.
Why It MattersDevelopers and operators running multiple agents now get more predictable scheduled behavior, because concurrent async tasks are less likely to pick up another agent’s runtime or tool context during execution. The migration from singleton state to context-local state should reduce context leakage and feature drift in async workflows, but because the old `async_agent_scheduler` import is now deprecated, teams should watch for integration regressions and validate scheduled jobs during upgrades.
Final score 74Confidence 951 evidence itemAsyncAgentSchedulerasync_agent_schedulercontextvarsglobal singletonstool resolution
In Goose PR #9325, the summon extension was updated to trigger subagent calls from @agent mentions or natural references in chat text, so users can invoke an agent without using a separate summon command format.
What ChangedIn Goose PR #9325, the summon extension was updated to trigger subagent calls from @agent mentions or natural references in chat text, so users can invoke an agent without using a separate summon command format.
Why It MattersDevelopers and operators using Goose can now route tasks to the intended subagent just by mentioning it in ordinary language, which should reduce friction and command friction in workflows, while the key risk to watch is accidental activation from non-command @text in normal conversation. This change extends summon routing from strict command paths to mention/heuristic matching, so monitoring should focus on false-positive triggers, incorrect agent selection, and any unintended execution from casual references.
Final score 73Confidence 951 evidence itemaaif-goose/goosesummon extension@agent mentionsubagent invocation
The PR adds an agent-driven workflow for El Salvador regulatory code search (ANDA, OPAMSS, MARN, etc.), connecting backend orchestration with a real-time UI so search sessions report coordinator/searcher progress and explicit partial completion states.
What ChangedThe PR adds an agent-driven workflow for El Salvador regulatory code search (ANDA, OPAMSS, MARN, etc.), connecting backend orchestration with a real-time UI so search sessions report coordinator/searcher progress and explicit partial completion states.
Why It MattersUsers and operators running Salvadoran code lookups will get immediate visibility into each agent's progress and a clear partial/no-execution outcome, reducing confusion and manual triage when searches stop before finishing. This is implemented through an Express-based orchestrator + WebSocket status stream tied to a React timeline, and the key watch points are skipped-state correctness on early exits, worker startup failures, and real-time event ordering after reconnects.
Final score 72Confidence 841 evidence itemagent orchestratorEl Salvador building-code searchspecialist agentsExpress APIWebSocketReact frontendpartial session status
The primary change in this PR is the async scheduler migration: `AsyncAgentScheduler` is introduced as the async-native path and wrapper context handling is rewired from global singletons to context-local resolution so multi-agent runs use a consistent runtime/tool context.
ContributionThis change adds `AsyncAgentScheduler` with periodic async execution, scheduling metadata, and retry behavior, then replaces wrapper-layer global singletons with `contextvars` so scheduler/runtime state is isolated per execution context and thread-safety is preserved across concurrent agents.
ImpactDevelopers and operators running multiple agents now get more predictable scheduled behavior, because concurrent async tasks are less likely to pick up another agent’s runtime or tool context during execution. The migration from singleton state to context-local state should reduce context leakage and feature drift in async workflows, but because the old `async_agent_scheduler` import is now deprecated, teams should watch for integration regressions and validate scheduled jobs during upgrades.
LangChain announces a shift from raw token streaming to structured agent streams across Deep Agents, LangChain, and LangGraph, adding typed events, scoped subscriptions, subagent visibility, and multimodal stream outputs for production-style agent applications.
ContributionIntroduces one coherent streaming model for agent systems: structured, typed events replacing token-only output, with built-in scoping and visibility so frontends can consume planning and subagent/multimodal signals directly from the stream.
ImpactApplication developers and operators can build agent UIs that react to higher-level execution milestones instead of parsing raw text streams, so interactive experiences become more stable and easier to debug during production use. The technical shift is the replacement of token streams with typed event streams in Deep Agents, LangChain, and LangGraph, which should reduce fragile frontend parsing paths and improve handling of tool-call progress, subagent responses, and multimodal outputs; teams should now watch subscription-filter correctness, event-schema compatibility across updates, and how existing integrations migrate from token-only handlers.
The PR’s strongest concrete change is the bump of @github/copilot-sdk from 0.2.2 to 0.3.0, enabling Copilot session-level authentication and finer-grained per-agent control (including tool visibility/skill injection and sub-agent streaming metadata) for integrations that build multi-agent workflows.
ContributionUpdated the Copilot SDK dependency in AGOR’s agent-sdks bundle from 0.2.2 to 0.3.0 so client integrations can use session-scoped GitHub identity and per-agent capability controls, including excluded tools and injected skills, instead of relying on a single process-level identity and flat agent behavior.
ImpactDevelopers running AGOR-based agent orchestrations can separate credentials and permissions by session and by sub-agent, which helps prevent accidental cross-user actions, quota mixing, and tool misuse in multi-user or multi-agent automation flows. The practical follow-up is to watch for any session reuse paths or stream consumers that still assume one identity and root-agent-only event IDs, because the new model changes how identity, permissions, and streaming events are associated and could break existing assumptions during rollout.
ACP command discovery is refactored to return one merged command set (built-ins + recipes + skills) so clients use a single source of truth for slash-command availability, instead of separate paths for each command type.
ContributionIntroduces a unified slash-command aggregation path so ACP exposes a single command catalog across built-in, skill, and recipe commands, with explicit collision precedence and shared slash-command handling for skills/recipes, reducing inconsistent command discovery behavior.
ImpactClients and operators using ACP can now discover and invoke slash commands more reliably from a single unified list instead of treating built-ins, skills, and recipes as separate, inconsistent surfaces, which reduces user-visible failures when a command is present but not shown through one command surface. The implementation merges command sources in `available_commands_update` using builtin > recipe > skill precedence and aligns skill/recipe invocation behavior, but teams should monitor for stale command lists when skills/recipes change (or working directories switch), because the PR notes no robust event-driven refresh path yet and stale catalogs can still cause wrong or missing suggestions.
This change moves summon’s subagent/skill discovery out of initialization and into the per-turn McpClientTrait instruction path, so agents or recipes added to .agents/ or .goose/ during an active session are visible on the next reply.
ContributionRefactored summon instruction loading to be dynamic per reply turn by implementing get_instructions() on the summon MCP client, replacing startup-time freezing of subagent listings.
ImpactOperators and developers can add or modify .agents or .goose extensions in a running Goose session and use them on the next turn without restarting or recreating the session, which prevents workflow interruption during long-running tasks. This is achieved by moving listing from SummonClient::new and InitializeResult::instructions into McpClientTrait::get_instructions, which the system already calls via prepare_tools_and_prompt → get_extensions_info every turn; watch next for added per-turn overhead and consistency behavior when extension files change while inference is in progress.
In Goose PR #9325, the summon extension was updated to trigger subagent calls from @agent mentions or natural references in chat text, so users can invoke an agent without using a separate summon command format.
ContributionAdded mention-aware dispatch logic in the summon extension so @agent handles and name-like references are parsed as actionable invocation signals, reducing the need for explicit command syntax.
ImpactDevelopers and operators using Goose can now route tasks to the intended subagent just by mentioning it in ordinary language, which should reduce friction and command friction in workflows, while the key risk to watch is accidental activation from non-command @text in normal conversation. This change extends summon routing from strict command paths to mention/heuristic matching, so monitoring should focus on false-positive triggers, incorrect agent selection, and any unintended execution from casual references.
The PR adds an agent-driven workflow for El Salvador regulatory code search (ANDA, OPAMSS, MARN, etc.), connecting backend orchestration with a real-time UI so search sessions report coordinator/searcher progress and explicit partial completion states.
ContributionIntroduced an end-to-end search pipeline in ruflo where backend orchestration spawns and coordinates multiple agents, validates retrieved URLs, and explicitly marks unfinished agents as skipped so session results show partial completion instead of unresolved ambiguity.
ImpactUsers and operators running Salvadoran code lookups will get immediate visibility into each agent's progress and a clear partial/no-execution outcome, reducing confusion and manual triage when searches stop before finishing. This is implemented through an Express-based orchestrator + WebSocket status stream tied to a React timeline, and the key watch points are skipped-state correctness on early exits, worker startup failures, and real-time event ordering after reconnects.
The main change in this burst is a correctness hardening of the ai-dev-kit agent-skill installer so installations are no longer treated as successful when skill selection, download, or GitHub tree parsing is wrong.
ContributionImplemented strict installation correctness in the agent-skill workflow by: resolving upstream/local skill-name mismatches with `source:install-name` handling, replacing fragile boundary-based matching with exact matching, parsing GitHub tree JSON in a format-tolerant way and filtering by blob entries, clearing stale destination directories on reinstall, and making success reporting conditional on complete file download success.
ImpactDevelopers and operators who install Databricks agent skills now avoid silent broken installs, so deployment and CI pipelines are less likely to proceed with incomplete skill packages and fail later at runtime. Concretely, the installer now only reports success after all selected skill files are fetched correctly, with partial or failed downloads surfaced explicitly. Watch for upstream GitHub API response-shape changes and any future drift in skill source names, because those remain the concrete conditions most likely to reintroduce install misclassification.
PR #1226 is an analysis-only feasibility paper that commits Agor to a hybrid topology where execution runs on a local agent while the hosted daemon remains the canvas source of truth. It rejects a standalone local Electron-only product and P2P as non-starters, and defines a phased D1–D8 delivery path with the largest technical risk concentrated in offline reconnection and authentication/authorization for long-lived agents.
ContributionThe pull request contributes a single strategic design decision: it locks in a hybrid distributed architecture for Agor worktrees and publishes an actionable implementation sequence, replacing broad exploration with a concrete plan and explicit sequencing constraints.
ImpactTeams that run Agor in collaborative environments now have a clearer path to keep worktrees local while still sharing a team canvas, which could unlock safer local development without forcing everyone onto a single remote execution mode. After this design, operators should watch whether the offline-buffer/reconnect work (D6), state conflict resolution (D7), and per-directive auth with fast revocation (D4) are implemented correctly, because these are the first gates that determine whether the plan is actually reliable in real-world use.
Cloudflare announced integration with Anthropic's Claude Managed Agents, adding a built-in isolated execution environment for autonomous code-delivery agents. The new environment is positioned for global agent workflow scaling on Cloudflare while enforcing controlled access to private backends and allowing teams to configure agent tools and runtimes.
ContributionCloudflare introduced a managed path for running Claude autonomous agents in isolated, configurable execution environments on its platform, enabling easier global scaling of agent-driven code delivery with enforced backend access controls.
ImpactDevelopers can run Claude-based autonomous coding workflows directly on Cloudflare without re-architecting for external hosting, which can reduce operational overhead and lower risk of exposing private services when automating development tasks; teams should now watch for access-control misconfiguration, secret handling in agent toolchains, and consistency of isolation policies as workloads scale across regions.
The PR rewires ByteRover skill installation to use a managed multi-file skill layout plus agent-aware install behavior, so global-only autonomous agents (Hermes/OpenClaw) can be installed without the old hardcoded project-scope assumption and with automatic BYTEROVER RULES insertion/removal in their system-prompt files.
ContributionAdded an agent-aware ByteRover install path that decomposes the skill into managed sub-skill files and injects/removes a bounded BYTEROVER RULES block into autonomous-agent system prompts, while making scope defaults agent-specific instead of forcing project scope.
ImpactOperators can now install or refresh ByteRover for Hermes/OpenClaw without manual prompt patching or scope-related failures, so autonomous agents are less likely to lose the memory contract that governs their behavior after each install/uninstall cycle. Under the hood, install state is now idempotent and tied to marker-bounded prompt blocks (`<!-- BEGIN/END BYTEROVER RULES -->`), and hub install defaults to per-agent scope (global for global-only agents), which should reduce support noise around `project`-scope errors. Continue to watch for regressions in custom system prompts and environment-driven path resolution, because those are still the paths that can cause wrong placement or skipped attachment.
Fixed a race in `cancel_run` where two concurrent cancel requests could both pass the pre-check and one call returned `409` after another had already interrupted the run; the API now re-checks state after `cancel()` fails and returns `202` when the run is already interrupted or already cleaned up.
ContributionAdded explicit post-`cancel()` re-read logic in the run-cancel path: if cancellation fails, the handler now inspects the latest run record and returns idempotent success for `interrupted` or missing records (cleanup races), with conflict only for completed/error/timeout states.
ImpactOperators and integrations that send duplicate cancel requests (for retries, timeouts, or concurrent controllers) now get deterministic success instead of random `409` failures when a run was already interrupted, reducing false alarms and unnecessary re-cancel loops while keeping protection against canceling already finished work.
After a failed `cancel()` call, the gateway re-fetches the run state and maps `interrupted` or absent records to `202`, while preserving `409` for successful/completed runs.
Watch for clients that previously treated any `409` as a terminal cancel error, and monitor conflict-rate telemetry under high-concurrency cancellation storms to catch any remaining race regressions.
This update makes GitHub Copilot CLI a first-class supported agent by adding official MCP plugin wiring and a dedicated connect path in agentmemory, enabling Copilot users to onboard with the same integration model already used by other coding agents instead of custom, error-prone setup.
ContributionImplemented native Copilot CLI onboarding in agentmemory by introducing plugin assets (`plugin/plugin.json`, `.mcp.copilot.json`, hook event config), adding a command path (`agentmemory connect copilot-cli`) that merges into Copilot MCP config while preserving existing keys, and normalizing Copilot camelCase event fields so observations flow through existing hook adapters—this removes a major integration gap and lowers the barrier to using Copilot CLI in the same agentmemory workflows.
ImpactDevelopers can now hook Copilot CLI into agentmemory with a supported setup path instead of ad-hoc config edits, so teams can capture Copilot tool events more consistently and reduce onboarding friction and config mistakes in local workflows. The change works by adding MCP-first plugin/install configuration plus idempotent CLI config merging and hook-field normalization, which should make Copilot integrations easier to operate across environments; watch for drift in Copilot event schemas, edge-case MCP-config merge conflicts when multiple servers are present, and Windows-specific command wrapping behavior that could reintroduce setup failures on some developer machines.
This change adds Hermes as a built-in agent and introduces a shared configuration path so all six builtin agents (claude, gemini, opencode, copilot, codex, hermes) now honor a uniform `[tool].command` and `[tool].env_file` override model, while fixing a case where env_file values for opencode/codex/copilot were silently ignored.
ContributionImplemented a unified override mechanism for builtin agent process launch options, adding Hermes to the same path with shared parsing/build logic and fixing env_file handling so it is no longer dropped via nil dispatch for opencode/codex/copilot.
ImpactOperators and developers using multiple built-in assistants can now configure startup commands and environment files consistently, so custom credentials and runtime flags are more likely to be applied correctly across agents instead of being silently ignored. This reduces broken tool sessions caused by missing env-based settings and shortens setup time when onboarding new agents, because Hermes now follows the same override pattern as existing builtins. The fix replaces the previous fallthrough path in env-file lookup and standardizes command building (`GetToolCommand`, dedicated builders), so behavior is predictable across six agents. Watch for command-precedence and tool-detection edge cases (especially Hermes binary matching/content patterns) that could still cause wrong process targeting under unusual local environments.
The PR adds end-to-end routing of watcher events from the agent dashboard into the matched conductor session’s tmux pane, by adding `RoutedTo` to `watcher.Event`, populating it in `engine.writerLoop`, and dispatching formatted events in `ui.Update` via `ui.dispatchWatcherEvent` instead of leaving them in the TUI only.
ContributionImplements a concrete behavior fix so GitHub/watcher notifications (PRs, comments, labels, CI outcomes) actually reach the intended conductor for action; previously they were only shown in the TUI and never delivered to the routed conductor’s execution pane.
ImpactConductor operators and automation flows can now see matched watcher events inside the target conductor pane as they happen, so GitHub activity can trigger immediate Claude reactions instead of being silently missed after reaching the dashboard. This is achieved by propagating router matches into each watcher event (`RoutedTo`), pushing them onto `routedEventCh`, and dispatching to `ConductorSessionTitle(evt.RoutedTo)` using the same tmux path already used by health alerts. Watch for whether required source settings are fully wired (dependency on the separate GitHub source settings work) and for coverage gaps where exact human-author matching misses bot-driven events, since those remain unrouted.
This commit burst centers on a user-execution fix for the agent container: it adds a /home/agent directory and introduces `--user` handling to run with the invoking user, addressing permission/ownership issues during containerized agent runs.
ContributionIntroduced a concrete container runtime behavior change so agent invocations can run as the current host user and have a mounted home path inside the container, reducing root-owned artifacts and permission mismatches with host files.
ImpactDevelopers and operators using OpenMonoAgent containers can avoid common permission-related breakage on generated files and mounted workspaces, so workflows like artifact creation, logs, and cache writes are less likely to fail or require manual chown fixes. Technically, the change creates `/home/agent` in the agent image and exposes a current-user execution mode (`--user`), which should improve ownership consistency for container mounts and filesystem writes. Continue to watch whether existing images/entrypoints that assume root execution or nonstandard home paths start failing, and whether UID/GID mappings remain stable across CI and shared-host deployments.
The pull request adds one unified global settings experience (`brv settings` plus synchronized TUI and Web UI surfaces) backed by validated, persisted storage loaded at daemon startup, so operators can inspect and update runtime controls from a single control plane.
ContributionImplemented a shared configuration path across interfaces: a persistent global settings store with validation and startup loading, exposed through the new `brv settings` command group and mirrored in TUI/Web UI so users can list, edit, and reset supported keys consistently.
ImpactOperators can now configure runtime limits and behavior from one place instead of hunting through separate CLI, TUI, and Web UI flows, which reduces mismatched settings usage and helps keep long-running local LLM jobs stable. The change adds startup-time validation and explicit restart-required handling to avoid silent invalid-config states, but it should be monitored for workflows that assume immediate hot-reload or need per-project overrides.
This change introduces a new `crush acp` command that enables Crush to run as an ACP server, adding core session and prompt flow support (initialize/authenticate/new session/prompt/model switching) plus lifecycle translation for permissions, tool calls, plans, and notifications. It consolidates prior ACP attempts and aligns the branch with current `main` while exposing ACP-compatible built-in and custom prompt/tool commands.
ContributionImplements ACP protocol integration in Crush by wiring session lifecycle and prompt handling through the new server command and translating pubsub events (messages, permissions, tools, plans, sessions) into ACP streamable session notifications, so external controllers can orchestrate Crush agents without adapter-specific protocol logic.
ImpactDevelopers and operators can now connect ACP-compatible clients directly to Crush as a server, which should reduce custom adapter work and simplify multi-tool orchestration of prompts, permissions, and tool actions during agent workflows. Technically, the PR completes ACP interface coverage (`acp.Agent`, `acp.AgentLoader`, `acp.AgentExperimental`) and publishes unified command/tool/session events via the Sink path, but adopters should continue monitoring for missing embedded-context support, unsupported media inputs, session-mode behavior gaps, and hidden startup errors from suppressed `NewAgentSideConnection` failures as rollout progresses.
The PR adds an explicit `skills/new` route and updates `SkillsView` to handle that path with `CreateSkillForm`, so “Create Skill” no longer falls through to `/skills/:skillId`; users without create permission are redirected to `/skills`.
ContributionImplemented a single concrete routing fix in the Agent Builder frontend: register `skills/new` as a dedicated route and branch `SkillsView` logic for that path to render `CreateSkillForm`, preventing it from being treated as a `:skillId` route; permission behavior is preserved by redirecting unauthorized users to `/skills`.
ImpactAgents using the Create Skill path in LibreChat now land on the correct create form instead of the wrong skill detail view, which reduces user confusion and failed workflow setup when building or editing agents. This is achieved by making `/skills/new` a first-class client route and routing it to `CreateSkillForm` before the parametric `/skills/:skillId` path; continue to watch for regressions in route matching around other skill URLs and verify redirects still behave correctly for users with partial permission sets.
This commit burst fixed a configuration chain that made MCP plugin CI fail deterministically even when plugin code itself was valid. By restoring omitted upstream artifacts in vendored plugins and making Bun types resolvable under strict pnpm isolation, the affected `mcp-plugins` checks now run as real quality gates instead of noisy sync/typecheck artifacts.
ContributionCorrected the vendoring and CI bootstrap path so real plugin correctness is now testable: the sync include/exclude rules were updated to retain needed tests and source paths (`*.test.ts`, `*.spec.ts`, `features/**`, `db/**`, `tsconfig.json`), and workspace typing resolution was fixed by hoisting `bun-types` via root `.npmrc` for strict pnpm isolation.
ImpactDevelopers and CI operators can now trust `mcp-plugins` results, because PR checks stop failing for non-code reasons and teams can focus on actual plugin regressions instead of debugging flaky sync tooling. After these fixes, CI checks in the touched MCP plugins now have clean local baselines (`bun test`: 717/717 and 331/331, plus successful `tsc --noEmit` runs), but monitoring should continue on future upstream syncs for newly introduced omitted paths, and on pnpm dependency-resolution behavior if the workspace grows with other bundler-sensitive toolchains.
After the 2026-05-17 quality audit, this PR records a second Intent Solutions Executive Decision Council run and approves a 5-session remediation sequence for the 8 remaining open items, prioritizing SKILL.md discovery, Caddy 404 fixes, and security/provenance evidence work while explicitly deferring lower-priority cleanup tracks.
ContributionIntroduced a formal decision record that transforms divergent reviewer outcomes into a single, prioritized execution plan with session-level ownership, making post-audit remediation traceable and bounded instead of ad-hoc.
ImpactMaintainers and operators now have a clearer execution roadmap for the unresolved audit findings, so the repo is less likely to leave critical quality/security items open while new work continues. This also locks deferred actions into a known backlog and documents override handling, so teams should watch whether each planned session is completed on schedule, whether SHA-pinning and provenance evidence are actually produced, and whether deferred tracks (like previous migration or rewrite tasks) are reintroduced without fresh justification.
run-llama/llama_index signaled that its workflow drawing package should be removed because that package has already been moved to the run-llama/workflows-py location, consolidating the tooling outside the main repo.
ContributionThis change deprecates/retains removal of the in-repo workflow-drawing package and relocates its stewardship to workflows-py, centralizing the component rather than keeping it duplicated in the llama_index codebase.
ImpactDevelopers and downstream projects that still rely on workflow drawing modules inside run-llama/llama_index may hit broken imports or setup issues during upgrades, so they will need to switch to the workflows-py package path to keep builds and automation working. The practical effect is reduced duplication and clearer module ownership, but teams should continue monitoring for stale dependency declarations, docs, and import references that still point to the removed package location.
Release v0.70.0 extends Crush retry behavior so temporary network issues (such as short disconnects or DNS failures) are retried automatically, instead of failing immediately when no specific HTTP error code is returned.
ContributionAdds explicit retry handling for network-layer failures in request execution, reducing manual recovery from transient connectivity issues.
ImpactUsers of Crush will experience fewer hard failures during brief network hiccups, so prompts and API calls are more likely to succeed without manual reruns or intervention. This is implemented by expanding the retry path from status-code-only conditions to include network exceptions, so operators should monitor for repeated side effects on non-idempotent operations, retry amplification during unstable links, and any increased upstream rate-limit pressure.
gentle-engram v0.1.6 updates startup behavior so Pi-launched/configured Engram processes with token+server settings automatically enable Engram core cloud autosync, reducing manual sync configuration for deployments.
ContributionAdded automatic cloud autosync activation during startup for Pi-launched/configured Engram processes when token and server are present, while preserving explicit ENGRAM_CLOUD_AUTOSYNC overrides and policy enforcement in Engram core/server.
ImpactPi operators and teams running configured Engram processes will get cloud autosync enabled by default when credentials are present, so synchronized cloud state is more likely to be active immediately after launch instead of requiring manual toggling, which helps prevent drift or missed updates; watch whether intentionally disabled autosync environments and legacy MCP launcher paths still behave as expected. The implementation keeps ENGRAM_CLOUD_AUTOSYNC as a hard override and keeps project enrollment/pause enforcement in policy, and it migrates only known legacy generated Pi MCP launchers to avoid altering custom MCP configurations, so migration safety should be the next operational check.
InsForge was announced as an open-source platform that lets AI coding agents handle backend deployment, operations, and debugging through a single CLI + Skills install, replacing fragmented integrations that previously required multiple MCP tools, dashboards, and manual config handoffs.
ContributionIntroduces a unified CLI/skills-based execution path for coding agents, so backend and infra tasks are orchestrated in one environment instead of via many preloaded MCP tools with heavy context and payload overhead.
ImpactDevelopers and operators can run backend lifecycle work (auth, db, deployment, debugging) through coding agents in one coherent workflow, which can reduce setup friction, context switching, and manual error-prone handoffs during prototyping and delivery. The practical significance is that agent-assisted shipping may become cheaper and faster in operator time, while the next risk to watch is whether promised safety controls—task-scoped permission expansion and snapshot-based rollback of writes—are robust enough before teams rely on it for production agent automation.
This PR applies a focused doc-and-rule cleanup from issue #1616 by removing unsupported `Rulesync target` claims from integration rows, correcting changed integration references, and adding the missing sentinel guidance in SKILL.md so the documented capability gaps reflect what is actually supported upstream.
ContributionConsolidated the rulesync capability guidance into a more reliable baseline by pruning unsupported target annotations, fixing drifted upstream links, and documenting sentinel-based behavior checks in SKILL.md so integration limitations are explicitly represented instead of being inferred.
ImpactDevelopers and operators using Rulesync are less likely to set up unsupported integrations from inaccurate docs, so fewer configuration attempts are likely to fail or silently misbehave when connecting tools like mcp-based clients. The PR strengthens the signal path from source references to runtime capability statements by re-checking URLs and standardizing the sentinel/capability-gap rule, but teams should keep monitoring upstream documentation and ignore-file naming conventions because those can reintroduce incorrect capability claims.
deer-flow now focuses on correcting run orchestration correctness by making historical persisted runs safer to read and easier to reconcile with in-memory state. When a worker restarts or reconnects are attempted, the system hydrates missing runs from the store, marks them as store-only, and avoids stale or malformed store rows causing hangs, so run recovery and monitoring remain usable instead of failing intermittently.
ContributionImplemented resilience around RunManager hydration and lookup paths so missing in-memory runs are fetched from RunStore with in-memory truth taking precedence, malformed or NULL persisted fields no longer break deserialization, historical store-only runs are detected before stream joins, and run listing returns deterministic bounded results instead of open-ended or unstable merges.
ImpactOperators and developers resuming or monitoring workflows after restart now get deterministic run recovery (a clear 409 or valid history) instead of indefinite joins or 500-style failures, reducing blocked follow-up actions during incident recovery. The implementation relies on store-only tracking plus guarded hydration/default handling in `RunManager` and `list_by_thread`; monitor whether client retry logic correctly handles the new store-only 409 path and whether high-concurrency create/hydrate races still surface as stale-state edge cases.
This PR adds an optional `all_projects` boolean to `mem_search` so callers can request cross-project lookup, while keeping default behavior unchanged when the flag is omitted or set to false.
ContributionIntroduced a concrete cross-project search path in the MCP layer by extending `mem_search` schema with `all_projects` and updating `handleSearch` to bypass project resolution when global search is requested.
ImpactDevelopers and operators can now retrieve memory search hits across multiple projects with a single `mem_search` call, so cross-project workflows no longer require repeated per-project queries or manual project switching; this is especially useful for debugging and agent operations that span project boundaries. The change is implemented in MCP request parsing and handler logic, which now routes `all_projects: true` to project-agnostic lookup while preserving existing scoped behavior for `false`/unset, so the next signal to watch is whether global results stay bounded by intended access controls and whether large multi-project queries introduce response latency or result-volume surprises.
Codeg now treats Grok as a native local ACP binary agent, registering it in the shared ACP registry and routing install/update/uninstall through the existing local binary cache path instead of a Grok-specific remote or resolver flow.
ContributionIntroduced Grok into the standard ACP local-agent path by registering it as `grok agent stdio` and binding it to existing binary-agent lifecycle logic, removing the need for a dedicated Grok remote registry while adding Grok MCP config and session parsing hooks.
ImpactUsers who deploy Codeg can onboard and manage Grok using the same local ACP tooling as other agents, so Grok no longer requires a separate setup path and is easier to install and maintain through existing workflows. This also means new Grok sessions should behave more consistently with existing local-agent operations because registration, updates, and cleanup now share the shared ACP registry + binary-cache behavior. Continue to watch for platform-specific failures in raw executable downloads and any regressions in Grok session resume/transcript handling that could block first-time setup or reopened sessions.
This release changes AionUi so agent warmup is deferred until a user starts typing, reducing eager startup work when sessions are idle.
ContributionIntroduces demand-driven initialization by moving agent warmup from automatic startup to lazy startup on first user input, so idle periods avoid unnecessary compute work.
ImpactOperators and end users should observe lower background overhead for inactive AionUi sessions because agents are not pre-initialized, but you should watch for any noticeable delay on the first keystroke in heavy interactions. The change shifts the warmup path to an on-demand trigger in the team runtime; continued observation should confirm first-input latency stays acceptable, downstream tasks still initialize correctly after deferred startup, and no pre-warm assumptions break hidden workflows.
Overstory updated @os-eco/mulch-cli from 0.6.5 to 0.8.0, adopting the new non-destructive lifecycle behavior where `ml prune` now soft-archives stale records instead of deleting them.
ContributionThe PR’s primary technical change is the v0.8.0 lifecycle update: record cleanup is changed to write stale items into `.mulch/archive/<domain>.jsonl` by default, and a matching `ml restore <id>` path was added to move recovered records back into active expertise files. Hard deletion remains available through `--hard` only.
ImpactOperators and developers using mulch now avoid irreversible cleanup losses during maintenance, because stale records are preserved in an archive instead of being removed outright and can be restored when needed. This is especially important for shared knowledge bases where over-pruning can remove useful context. Track archive growth and cleanup policy, and verify restore behavior in multi-domain setups where ambiguous IDs can still fail, so you know when recovery workflows become operational bottlenecks.
Release v5.8.1 for dmux is a focused bug-fix update that reduces noisy attention notifications, aiming to cut down repeated alert chatter from attention events.
ContributionIntroduced a bug fix that lowers the volume of attention-triggered notifications, reducing excessive alert emission from dmux.
ImpactOperators and developers using dmux will see fewer repetitive attention alerts during normal operation, so they spend less time on false positives and can focus faster on actionable incidents. The release appears to tighten the attention-notification emission behavior; teams should watch for any drop in legitimate critical alert visibility or delayed detection under high-load workflows.
v13.2.0 introduces the new `wowerpoint` skill, which automates turning one source document into a kawaii-style NotebookLM slide-deck PDF via the `notebooklm` CLI, while enforcing single-source input before export.
ContributionCreates a concrete new end-user capability: single-document deck generation as a built-in skill, with asynchronous execution behavior that decouples long rendering work from the active assistant turn.
ImpactOperators and users can build long-running slide-deck outputs without stalling the conversation, so they can keep interacting with the agent while a document is being rendered into a PDF. This is implemented through a strict workflow (single source file first, then rendering) plus required local dependencies (`notebooklm-py`, Playwright Chromium, `jq`), so teams should watch for environment setup failures, template-output quality drift from the fixed kawaii prompt, and reliability of large renders as NotebookLM and Playwright versions evolve.
Agent Orchestration Platforms showed a tracked change with evidence attached, making the topic easier to monitor over time.
ContributionConcrete fix: updated `scripts/sync-plugin-version.js` to use object-array targets with `path`/`field` and sync nested version fields (not only top-level `version`), then bumped `.claude-plugin/marketplace.json` plugin version to 1.3.0 so marketplace metadata matches the released package.
ImpactHelps teams decide whether this direction deserves continued tracking.
The release introduces SANDBOX_KVM_ENABLED so sandbox containers can use host KVM for VM execution instead of slower software emulation when enabled.
ContributionAdded a new environment-controlled sandbox runtime mode that exposes /dev/kvm to containers, enabling hardware-assisted VM execution in environments that support KVM.
ImpactDevelopers using OpenHands sandboxes can get faster execution for VM-based tasks when they enable KVM mode, which reduces waiting time during interactive workflows. The new SANDBOX_KVM_ENABLED toggle now routes sandboxes to host hardware virtualization through /dev/kvm instead of emulation, so operators should verify host virtualization support, container privilege policy, and isolation/security posture before rolling it out widely.
Google ADK Go v1.2.0’s primary change is native Agent Engine support via a new ADK Go CLI deployment path, moving agent rollout toward a first-class managed-runtime flow instead of custom external wiring.
ContributionAdded built-in Agent Engine integration in google/adk-go, including CLI-driven agent deployment mechanics, so teams can provision and run agents on Agent Engine using repository-supported tooling rather than manual orchestration.
ImpactDevelopers and platform operators can deploy ADK agents to Agent Engine directly through the CLI, which can reduce rollout friction and speed up promotion from local/prototype use to managed cloud execution; teams should closely observe deployment permissions, event routing, and execution entry-point wiring in staging because regressions there could cause silent routing failures after migration.
agor-live v0.15.0 introduces GitHub Copilot SDK integration so the platform can launch and manage Copilot agent sessions with token-level streaming, permission mapping, and MCP compatibility.
ContributionAdded a new Copilot session execution path in agor-live that connects the platform to the GitHub Copilot SDK, enabling in-product creation and control of Copilot agents and streaming interaction flow through MCP-aware tool routing.
ImpactDevelopers and operators using agor-live can now run Copilot-powered agent workflows inside the platform instead of switching context across separate clients, which can materially speed iterative automation and debugging; the practical follow-up is to confirm that this beta-based path is stable in real deployments. The implementation relies on Copilot SDK + MCP integration and related auth/session handling changes, so teams should keep watching token-exchange failures, OAuth callback behavior, and permission-mapping edge cases before broadening production use.