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 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.