Past Daily Editions
Every issue of The Git Reporter is grouped by publication date, with each day's lead story, companion articles, and evidence trails kept together.
An Agent’s ‘No’ Needs a Way Back—But Not a Shortcut
Qwen Code now offers one manual review only for the exact action its AUTO mode blocked—turning a false positive into an accountable decision instead of a workaround hunt.
Hermes Decides That a Preference Can Have a Home
Hermes is redrawing a deceptively important line: a correction learned while doing one task belongs with that task's skill, while persistent memory is for facts that should matter everywhere.
Before Codex Trusts a Workspace, It Stops Letting the Workspace Choose Its Helpers
A merged Codex change moves automatic pre-trust helper lookups to known system locations, sanitizes plugin-sync Git, and makes diagnostics inspect a workspace-influenced path without running what they find.
A Child Agent’s Approval Request Shouldn’t Hide in Another Tab
Openwork now brings a child session’s blocked permission into the parent task; fresh Goose state-machine work shows why seeing the ask is only half the control.
A Completed Agent Run Is Not a Successful One
OpenHands now treats a finished process and a successful task as different facts—so an automation can be completed, blocked, and operationally failing at the same time.
The Company Can Host the Agent. The AI Account Can Still Be Yours.
QM is separating the place an agent is operated from the account that pays for and authorizes one person’s model turn—while deliberately leaving background work on organization credentials.
The Last Click Shouldn’t Redirect an Automation
OpenWork has stopped a scheduled Automation from silently following whichever workspace a person activated last; a job can now carry its intended place with it.
A Restricted Workspace Should Not Start Its Own Tools
Gemini CLI now gives an explicitly restricted or untrusted workspace a narrower configuration path: repository-defined tools, MCP servers, policies and telemetry no longer accompany its A2A server into startup.
The Old Proxy Is Gone. OpenWork's Cloud Has One Door Now.
OpenWork has deleted its standalone cloud-worker proxy; the public replacement makes a fresh signed preview the access-resolution seam while keeping a stable route for clients that cannot hold an expiring address.
Before Docker Reads the File
Headlong’s Docker broker is treating the pre-render Compose file as an authority boundary—because a path is no longer safe to inspect after the renderer has already opened it.
A Shared Terminal Is Not Shared Permission
OpenClaw’s new terminal-input path separates an agent being allowed to see an operator’s terminal from being allowed to send a keystroke into it.
Codex Puts a Broker Between the Agent and the Secret
A newly merged Codex change says a project file can describe the work, but it should not be able to switch on the credential broker or choose the provider context that reaches an agent shell.
Unsloth Built a Benchmark That Can Veto Its Own Speed Claims
The new StudioBench is designed to make a performance result fail before it makes a flattering headline.
Before Cline Replaces an Agent Hub, It Starts Saying No
Cline’s Hub can now refuse new mutable work, wait for accepted sessions to settle, and replay a durable event stream to reconnecting clients before an upgrade swaps the service underneath them.
A Release Should Not Fetch Its Rules From a Moving Main
OpenClaw is making a narrow release promise: when the product is frozen, the workflow allowed to publish it must stay identifiable even after main changes.
Qwen Code Saves the Shape of a Finished Workflow
Qwen Code is teaching a finished multi-agent run to leave behind a reviewable shape—rather than a pile of logs that dies with the terminal.
Cline Lets an Agent Schedule Work—But Not Anywhere It Likes
Cline's new durable task system lets an agent make work recur after the chat ends, but its public implementation keeps asking the harder question: which workspace gave that job authority?
An Approval Must Keep Its Denials
Codex is tightening the rules beneath its approval layer: a broad remembered grant must not reopen a denied child path, an unfamiliar shell must identify itself, and a stale reviewer score should be visible as stale.
An Agent Can’t Review the Wrong Tree
Qwen Code has made a workflow subagent’s linked worktree part of the job itself—a small API change with a large warning for anyone resuming, reviewing, or testing code across branches.
When a Context Limit Drops the User’s Turn
OpenClaw found a required Codex compaction preflight treating an intentional no-op as a fatal failure—so an overlong session could lose the incoming user turn before the model ever answered.
A Sandbox Isn’t Finished Until the Repository Says So
Mastra Factory is making one understated agent-system choice explicit: before a session workspace is scrubbed, pooled, or destroyed, the repository can say how its own worktree should be put away.
Codex Stops a Thread’s Permission From Leaking Into a Read-Only Environment
A new Codex regression test makes the sharpest promise in its permissions work: a selected environment configured read-only must stay read-only even when the surrounding thread can write.
A Forgotten Tool Is No Longer Callable in Pydantic AI
After compaction hides how a deferred tool reached an agent, Pydantic AI now makes the agent put that evidence back before the call can go through.
A Session Approval Needs Something to Hold On To
Two fresh code changes make the same point: a human’s “yes” is only useful when an agent can name exactly what that yes still authorizes.
OpenClaw’s shared channels gain a per-requester login
A new opt-in OAuth mode for HTTP MCP servers lets a trusted sender connect their own account instead of letting the whole room run on one operator credential.
Coding Agents Are Building Themselves—But Git Can Prove Only Part of It
Across 40,345 unique commits in ten public agent codebases, coding-agent credit becomes sharply more visible in 2026—and the missing receipts matter as much as the names that appear.
In Mastra’s Approval Queue, the Second Yes Needs Its Own Address
An open Mastra core pull request treats a human approval as a per-tool-call decision, not a vague signal attached to an entire agent run.
Cline gives a finished agent answer a diff receipt
Cline’s restored “View Changes” control makes a completed agent turn point to a checkpointed file delta—not just its own verdict.
Hermes now stops agents from quietly rewriting their own instructions
A new Hermes Agent write gate treats project instruction files as a persistence surface: even an auto-approved agent must ask a human before it changes the text that can steer tomorrow’s work.
A Denied Agent Answer Should Not Survive in Memory
Microsoft’s experimental Agent Hooks adapter treats a rejected response as a session-history problem too: the verdict is meant to arrive before the reader sees it and before the affected context becomes durable.
Permissions now travel with Codex’s work environment
Codex is moving a permission choice out of the thread’s background and into the selected environment that runs the command, applies the patch, sees the image, and carries work to another agent.
Tau Will Ask Before It Reads a Project’s AGENTS.md
Tau’s new Project Trust layer turns local instructions, skills, prompts, themes, and extension candidates into a directory-specific decision before they become ambient agent input.
The Agent Can Refile a Worktree, Not Rewrite the Filing Cabinet
Kilo Code’s new Agent Manager move gives an agent a way to reorganize parallel work—only through a live inventory, a targeted command, and a hard boundary around the recovery file.
Agent Behavior wants to make good conduct a versioned artifact
Braintrust and Basis propose a tiny BEHAVIOR.md standard as the answer key between runtime instructions and agent evals. The file is easy; writing conduct that remains observable across real trajectories is the actual work.
An Approval Cannot Outlive the Conversation That Asked for It
Cline fixed a small but revealing failure in its VS Code extension: change a message while a command approval is waiting, and the old run could keep waiting forever—then catch answers meant for the new one.
QM is trying to turn the personal agent into company infrastructure
Y Combinator's new open-source harness does not win its case by running Codex or Claude in Slack. Its more consequential bet is that every person and room needs a clearly owned memory, workspace, permission set, schedule, and durable computer.
Browser Use: the control boundary between an agent and the live web
Browser Use’s latest harness release and its own session examples make a harder point than a benchmark: browser automation only becomes legible when profile, destination, and data authority are named controls.
OpenHands: separating the software agent from the sandbox it works in
A new healthy-local-backend fallback makes the project’s larger argument concrete: the thing that helps a person steer an agent must stay legible even when the agent is running somewhere else.
An Agent Framework Can Carry Your Request—Not Your Responsibility
Microsoft Agent Framework's newest A2A and BYOK samples make one quiet operating rule visible: let a caller's configuration cross the boundary, but leave the host's policy and the provider's obligations where they belong.
When an Agent Sees Two MCP Servers Called Docs
OpenClaw’s Code Mode has a new answer to a quietly consequential question: when several connected machines offer a server called docs , how does an agent know which one it is calling?
Before Goose Runs a New Model, Pick Its Permission Mode
Goose has mapped Claude Opus 5 into its runtime. Before a new model reaches local tools, the operator still has to decide whether the session runs automatically, asks first, uses risk-based approval, or stays in chat.
An Agent’s Answer Begins in the Harness
The model only sees the task after a runtime has edited its context, carried forward state, and decided what survived the last turn—so the first question after a bad run is what the harness made it see.
The 67,000-Star Repo That Changed What It Was
Open Interpreter’s GitHub audience remembers a Python computer agent. The code behind the same counter is now a Rust fork of Codex—and almost all of the stars arrived before that switch.
An Agent's Sign-In Link Is Not a Timeout
OpenWork's newest MCP work carries a provider's structured authorization link through a failed tool call, so the person who owns the account can act instead of watching an agent retry the wrong problem.
The Diff Can't Be Guesswork Once an Agent Writes
OpenClaw is making a simple rule explicit: when an agent writes a file, a review surface should show the patch it can prove—and show uncertainty when it cannot.
A Computer-Use Agent Needs a Second Meaning of Success
Hermes now tells a desktop-driving agent whether an input merely reached a driver or was actually confirmed to have changed the interface—and it makes foreground escalation a separate decision.
Gemini CLI’s Caretaker Has Permission to Read, Not to Act
Gemini CLI’s new issue-triage worker gives its model a read-only repository view, then keeps labels, comments, retries, and escalation in a separate validated program.
The Hard Part of an Agent Protocol Rewrite Is Yesterday
Tau is replacing its legacy agent protocol with Pi-compatible shapes, but its more consequential promise sits at the JSONL boundary: old sessions are meant to cross without pretending the old runtime still exists.
Codex Keeps the Prompt After You Interrupt It
A new Codex TUI change treats an interrupted request as part of the record, then gives the next instruction a clean composer.
Background Agent Work Needs a Receipt
Hermes and OpenClaw are fixing different failure windows in the same promise: delegated work has to arrive somewhere a person can use it.
Codex Makes Thread History a Rebuildable View
Two fresh commits separate a coding agent’s durable JSONL record from its fast SQLite history view—and teach that view how to catch up after it falls behind.
OpenWork Gives MCP Failures a Useful Address
A new diagnostics layer separates DNS, TLS, HTTP, OAuth, protocol, and provider failures, then returns a bounded reference and the person who can act—without logging the raw connection secret trail.
Hermes Turns Health Checks Into a Runtime Contract
A new authenticated readiness endpoint checks the parts of an agent gateway that can make it unreliable—without reading payloads, leaking configuration, or trying to repair anything.
Entire Gives Agent Work a Separate Git Address
The CLI stores prompts, tool calls, touched files, and now images on a checkpoint branch—making an AI coding session resumable, and potentially shareable by accident.
OpenWork Makes MCP Sessions Durable
OpenWork's July 9 commits changed cloud auth and MCP client state so agent connections can survive refresh, offline access, and cross-origin client paths.
Agent Runtimes Move Trust To The Exit Gate
OpenClaw, Codex, and Hermes all changed runtime trust surfaces this week, making the last moment before a tool call, secret handoff, or approval the place operators need to inspect.
Gemini CLI Turns Issue Triage Into A Caretaker Worker
Gemini CLI added a caretaker triage worker and GitHub egress handler, moving issue sorting toward an agent-run workflow with locks, retries, labels, comments, and human handoff states.
OpenClaw Makes Agent Audit Trails A Runtime Contract
OpenClaw added a metadata-only audit ledger on July 6, giving operators a way to inspect agent run events, native-search outcomes, tool actions, statuses, and errors without opening full transcripts.
Hermes Makes Yolo Obey User Deny Rules
Hermes added `approvals.deny` on July 5, giving users glob rules that block terminal commands even when the agent is running in yolo or approvals-off mode.
OpenCode Turns OpenAPI Into Agent Tool Contracts
OpenCode merged a CodeMode OpenAPI adapter on July 4, giving hosts a way to turn API specs into model-visible tools while keeping credentials and unsupported operations outside the agent's reach.
OpenWork Makes Team Memory A Governed Agent Surface
OpenWork's July 2 Memory Bank merge turns saved agent context into a user-scoped, searchable capability with tests, schema checks, and explicit no-secrets guidance.
OpenCode Turns Agent Review Into A First-Class Work Surface
A July 2 review-panel overhaul moves OpenCode's agent output closer to a readable control surface for changed files, comments, media, and stability checks.
OpenClaw Lets Agents Wake After A Command Exits
OpenClaw added an on-exit cron schedule so a gateway-owned watcher can wake an agent after a watched process finishes.
Hermes Makes Agent Approvals Thread-Local
Hermes replaced a shared approval flag with thread-local state, then paired that control with secret redaction and delegation-budget tests.
OpenClaw Narrows Who Can Wake An Agent
A cluster of OpenClaw commits put scheduled wakes, ACP runtime controls, and browser proxy invocation behind narrower target and scope checks.
Tau Turns Agent Architecture Into Onboarding
A Tau documentation rewrite moved the coding-agent project from build-log internals toward a public quickstart, reference, package, and license surface.
Codex Makes Plugin Trust Runtime Policy
A new Codex plugin patch turns marketplace source restrictions into runtime filtering, loading, and cache-refresh behavior.
Agent Safety Gates Catch Edge Cases
Gemini CLI, OpenClaw, and Hermes all turned ordinary boundary mistakes into explicit control failures.
Mistral Vibe Makes ACP Compatibility A Release Contract
Mistral Vibe 2.18.0 turns ACP behavior, editor setup, auth cleanup, and fork-session limits into release-visible evidence.
OpenWork Puts Self-Hosting On The Checklist
OpenWork's June 24 code changes make deployment configuration, readiness, packaging, and user-flow proof visible as project maturity work.
Model Catalogs Get Plain-English Receipts
LangChain and Pi are making model/provider changes easier to inspect before they become hidden assumptions inside agent runtimes.
Agent Control Hints Become Runtime Contracts
Fresh OpenClaw, Codex, and Hermes changes show agent projects turning speed modes, chat metadata, and worker instructions into explicit runtime surfaces.
Agent Tools Get Back-Pressure Surfaces
Fresh Gemini CLI and OpenWork patches show agent products turning hangs, publish failures, voice quotas, and provider outages into explicit runtime behavior.
Agent Runtimes Are Learning When To Stop
Fresh OpenCode, Codex, OpenClaw, and Hermes Agent patches show agent tools turning long-running work into bounded, traceable runtime state.
Agent Tools Are Getting Capability Switches
Fresh Codex, Hermes Agent, and Pi patches show agent projects narrowing when external skills, MCP tools, and package surfaces become visible.
Agent Control Panels Move Into The Terminal
Hermes Agent, OpenClaw, and Codex all moved user-facing control surfaces closer to the agent runtime, from billing and provider setup to structured MCP prompts.
Mistral Vibe Turns Release Claims Into Trust Boundaries
The v2.16 release line says workspace trust, resume speed, diff rendering, SSE parsing, and backend reasoning behavior are no longer only UX claims; several now have code and tests behind them.
OpenWork Turns OpenCode Into A Team Workbench
The OpenCode-powered project is building a local-first desktop and server layer so agent work can be run, shared, permissioned, and audited from one product surface.
Agent Tools Are Moving Safety Into Boundaries
Gemini CLI, LangChain, and Codex landed fresh patches that put agent safety in filesystem checks, type gates, pending-tool waits, and permission-path parsing.
Agent Clients Are Learning Where Work Belongs
Fresh Codex, OpenCode, and Pi patches show agent interfaces routing threads, draft sessions, and terminal setup by local context before the user acts.
Agent Sessions Are Getting Recovery Paths
Fresh OpenClaw, OpenCode, Hermes Agent, and Codex patches show agent tools treating interruption and recovery as runtime work, not edge-case cleanup.
Agent Context Gets Filesystem Boundaries
Fresh Crush, Codex, OpenClaw, and OpenCode changes show agent runtimes separating user memory, project context, and sandbox paths before work starts.
Agent Tools Are Getting Credential Boundaries
Fresh OpenCode, OpenClaw, Hermes Agent, and Codex commits show tool access becoming a credential and trust-routing problem, not only a menu of callable functions.
Agent Tooling Gets Runtime Guardrails
Fresh OpenCode, LangChain, Gemini CLI, Codex, and OpenClaw commits show agent projects tightening the machinery around tools, sessions, streams, and approvals.
Agent Trust Is Moving Before the First Tool Call
Fresh Pi, OpenClaw, and Codex changes point to a quieter layer of agent safety: decide what a project may load, what a gateway may carry, and what execution context a thread owns before the model starts acting.
Agent Automation Is Becoming Scheduled Operations
Fresh OpenClaw, Codex, and Hermes Agent commits show agent work moving beyond the foreground chat turn into scheduled jobs, background threads, heartbeat runs, and provenance-aware session rotation.
Agent Setup Is Becoming Runtime Onboarding
Fresh OpenClaw, Hermes Agent, and Codex commits show agent tools trying to erase the gap between "this capability exists" and "a user can actually run it."
Agent Control Is Moving Into the Live Interface
Fresh OpenClaw, Crush, Hermes Agent, and Codex commits show approvals, steering, and configuration errors moving from background policy into the moments where a human can actually change an agent run.
Agent Identity Is Becoming Runtime Infrastructure
Fresh Hermes Agent, OpenClaw, and Codex commits show profile, credential, and model-choice state moving out of setup screens and into live agent runtime controls.
Agent Events Are Getting Return Addresses
Fresh Hermes Agent, Crush, OpenClaw, and Codex commits show agent runtimes attaching correlation, provenance, and client identity to events so the right run, session, surface, or device receives them.
Agent Failure States Are Becoming Instructions
Fresh LangChain, Crush, Gemini CLI, and OpenClaw commits show agent tools turning denial, fallback, routing, and policy drift into explicit next steps.
Agent Work Is Getting a Back Button
Fresh Codex and Hermes commits show a practical shift in agent tooling: longer-running work now needs recovery rails, not just more controls.
Agent Policy Is Moving Into Delivered Layers
Fresh Codex and Hermes commits point to a new control-plane pressure: the rules an agent follows are starting to arrive as cloud bundles, layered requirements, and entitlement-aware tool setup instead of only local config choices.
Agent Tool Menus Are Becoming Runtime Infrastructure
Fresh Codex and Hermes commits show a quieter agent shift: the visible list of tools is becoming a runtime contract about what can be suggested, enabled, discovered, and checked without breaking the session.
Agent Control Settings Are Becoming Session State
Fresh Codex and Hermes commits show a quieter agent shift: permissions, tool behavior, lineage, approval context, and auth fallbacks are being treated as state that has to survive the next turn.
Agent Sandboxes Are Learning Their Cleanup Rules
Fresh Codex and Hermes commits point to a practical agent shift: the local machine is becoming part of the runtime contract, with workspace roots, filesystem denies, Docker persistence, orphan cleanup, and lifecycle commands written down in code.
Agent UI Is Becoming the Control Room
Fresh commits in Codex, Hermes, and Gemini CLI point to a practical agent shift: the human interface is turning into the place where long-running work gets linked, stopped, switched, and steered.
Agent Context Becomes Runtime State
Fresh commits in Codex, Gemini CLI, and Hermes point to a quieter agent shift: context is being stored, routed, measured, and traced instead of merely stuffed into prompts.
Agent Reliability Is Moving Into the Test Rig
The newest source-readable trail points away from model mystique and toward the workflows that test, trace, serialize, and maintain agent behavior.
Agent Runtimes Are Learning Where to Say No
After shipping more visible control planes, agent projects are now tightening the places where tools, plugins, credentials, chat context, and test runs are allowed to flow.
Agent Runtimes Are Learning to Ship Their Control Plane
A set of Codex, Hermes Agent, Gemini CLI, and Crush commits shows agent tools packaging the machinery around the model: shells, platform adapters, context profiles, and skill catalogs.
Agent Runtimes Are Making Their Limits Explicit
Recent Crush and LangChain changes show agent infrastructure turning hidden boundaries - shell permission, context overflow, and model token limits - into runtime contracts that users and developers can see.
Agent Goals Are Becoming Runtime State
Recent Codex and Hermes Agent changes show coding agents turning goals from chat commands into durable metadata, resumable session state, and queued work control.
Agent Runtimes Are Moving State Out of the Shadows
Recent Codex and Gemini CLI changes show coding agents treating settings, queued input, subagent starts, and terminal streams as explicit runtime state instead of invisible side effects.
Agent Runtimes Are Learning to Audit Their Own Tools
Fresh Codex and Gemini CLI changes show agent projects treating tool calls, plugins, MCP servers, and subagents as auditable runtime events instead of invisible helper work.
Agent CLIs Are Turning Permissions Into a Conversation
The next shift in terminal agents is not just better tools or tighter sandboxes. It is that permissions are becoming live workflow state: negotiated mid-task, scoped to the action, and remembered with just enough structure to keep work moving.
The Real Agent Feature Is Not Losing the Plot
The next terminal-agent moat is not just better tools or bigger models. It is continuity: whether the system can keep plans, transcripts, and working context coherent as sessions stretch, compress, resume, and hit real-world friction.
The CLI Is Becoming an Agent Workbench
The real shift in terminal agents is not bigger models or flashier demos. It is that planning, task state, plugins, and long-lived runtime context are turning the CLI into a place where work gets organized, not just requested.
From Tool Chatter to Chapters: Agent CLIs Are Inventing a Narrative Layer
The interesting shift this week isn’t just that Codex and Gemini CLI can do more. It’s that they’re getting better at explaining themselves while they work —turning raw tool noise into something a human can actually follow.
The Next Agent UX Moat Isn’t Speed. It’s Backpressure.
The hard problem in terminal agents is no longer just getting them to do more. It’s deciding what happens when the human tries to steer while the runtime is already busy.
Subagents Aren’t Just Getting Smarter. They’re Getting Contained.
The next terminal-agent upgrade is not more helpers. It’s better walls: isolation, cleanup, bounded autonomy, and fewer chances for delegated work to spill across the room.
The CLI Is Quietly Becoming an Agent Router
The next terminal-agent shift is not another flashy planning demo. It is the quieter, harder job of helping remote agents actually connect: across protocols, proxies, auth flows, and messy metadata.
The New CLI Moat Isn’t UX. It’s How Agent Skills Get Shipped
This week’s most strategic terminal-agent shift is not another demo flourish. It’s the quiet work of turning capabilities into things that can be packaged, cached, moved, and trusted.
The Next CLI UX Battle Is Agent Forensics
The most important agent upgrade this week is not another tool. It’s the growing ability to reconstruct why an agent touched files, spent tokens, and arrived at a code change in the first place.
Codex forks it, Gemini threads it: execution context becomes first-class
The next big agent primitive is not another tool call. It’s the bundle of permissions, environment, policy, and wiring that tells an agent how to exist for this turn, in this loop, right now.
Parallel agents are getting real addresses
This week’s most important agent upgrade isn’t more raw intelligence. It’s workplace logistics. Gemini CLI is giving parallel sessions separate rooms. Codex is giving subagents names you can actually point at.
AI agents are getting better at saying “here’s what I finished”
The real upgrade this week isn’t bigger context or flashier autonomy. It’s something more human: when an agent stalls, waits, delegates, or times out, it’s starting to leave behind a useful trail instead of a shrug.
Before the Prompt Lands: Codex and Gemini Turn Hooks Into Agent Control Planes
Terminal agents are growing a new kind of muscle: not just better tools, but better middleware. In both Codex and Gemini CLI, the moment right after you hit Enter is becoming programmable territory.
Gemini Lets the Model Schedule Parallel Tools. Codex Makes the Runtime Decide.
Terminal agents are learning the same trick — run more tools at once — but Gemini CLI and OpenAI Codex disagree on who should be in charge of that decision. One pushes dependency control up into the prompt and tool schema. The other keeps it down in runtime metadata and locks.
Subagents Grow Up: Gemini Isolates Tool Boundaries While Codex Shares Trust by Default
Two agent platforms shipped subagent changes within hours of each other. One tightened what a child agent can see and use . The other tightened what a child agent can teach the rest of the system to trust . Same category. Very different instinct.
OpenViking Turns Agent Memory into a Filesystem — and That Changes the Game
Agent memory has felt like a junk drawer: we throw context in, pray the model finds it, and hope the glue holds. OpenViking’s bet is bolder — treat memory like an operating system, not a sho...
Gemini CLI Turns File Tools into Context Sensors — Right as A2UI Trends
Today’s GitHub Trending list says the same thing twice in different languages. A2UI is climbing because teams want UI‑level schemas that keep agents from guessing. At the same time, Gemini C...
Gemini CLI Built the Ask‑User UI That MCP Elicitation Still Needs
Elicitation is the moment an agent has to stop and ask you a question — a human speed bump that keeps automation honest. This week, Gemini CLI users reported MCP servers failing with a “Meth...
Page Agent’s MacroTool Makes In‑Browser Agents Resilient to Messy Tool Calls
GitHub’s trending list has been noisy with “agent frameworks,” but Alibaba’s page-agent stands out because it runs inside the web page instead of driving a separate headless browser. That ar...
Gemini CLI Makes MCP List-Changed Notifications Resilient
Gemini CLI’s PR #21050 fixes a rough edge in MCP notifications: tools/list_changed updates could be missed, leaving clients out of sync with what a server actually offers. The client now reg...
Codex Makes Memories a First-Class Writable Root—and Stops Cleaning Through Symlinks
Codex just turned its “memories” folder from a side alley into a well-lit main road. And it put a lock on the janitor’s closet so cleanup can’t accidentally bulldoze someone else’s house. Th...
Gemini CLI tightens MCP tool discovery: debounced list_changed refresh, trailing queue, and resilient retries
Gemini CLI’s MCP integration has been steadily gaining real-time awareness of server-side tool changes. A local search trail points to early MCP notifications support landing on 2026-01-08 (...
Codex Rust CLI Update: Memory Writes Now Fit “workspace-write” and Safer Clears Land in f72ab43
The Codex Rust CLI just got a small but meaningful quality-of-life upgrade—one that also tightens safety around memory cleanup. In PR openai/codex#13467 (commit f72ab43fd193b31208cd3c306293b...
Gemini CLI Makes a “Generalist” Sub-Agent the Default Delegate
TheGitReporter — In a recent core change, Gemini CLI quietly shifted delegation from an opt-in feature to a baseline capability. Gemini CLI has landed a new default behavior: a built-in gene...
Gemini CLI and Codex Level Up MCP Safety and Setup: Trust Prompts vs Auto-Install Skills
Two CLI assistants walk into the same tooling bar. One checks IDs at the door; the other quietly installs the band’s gear before the show starts. Gemini’s new “trust, but verify” moment Gemi...
Persistence vs Freshness: Codex and Gemini CLI Tighten Two Different Boundaries for Agent Workflows
On March 4, 2026, two quiet merges landed on opposite sides of the agentic tooling ecosystem—both aimed at making “hands-off” workflows less surprising. OpenAI’s Codex and Google’s Gemini CL...