Stories from the source. Scroll back through the reporting, one day at a time.
What’s up today? →
MultiLangBench asks a model to build a database engine in a chosen language. The revealing part is the examiner: reference SQLite reads the file that implementation leaves behind.
Read story & evidence
New Studio code gives chat, image and video models a choice: share GPU memory when possible, make room, or refuse a disruptive load. When media does displace chat, it can also save the primary GGUF model’s cached work.
Read story & evidence
New request observers expose outcomes and available token usage. Where you put them in the sequence changes when a tool can leave the queue.
Read story & evidence
Pi’s experimental durable harness now stores a sleeping task’s deadline and next step, letting a host alarm bring execution back later. The change separates continuing work from a continuously running process.
Read story & evidence
The agent’s development branch swaps PCTX’s Deno-based runtime for Boa. It keeps the ability to discover tools and compose their results, while removing generated TypeScript and a chain of build workarounds.
Read story & evidence
Google’s open-source terminal agent now warns that it is not optimized for Gemini 4 Argon. The recommendation makes its direction clearer while fresh implementation fixes show a project still being maintained.
Read story & evidence
Every’s origin story celebrates a desktop built around agents. The public record reveals the quieter achievement underneath: separating the machinery that does the work from the interface that helps people direct it.
Read story & evidence
The shared workplace agent is narrowing its runtime choices to Pi and Claude. Its October 14 code change shows why keeping a model connection does not require keeping the agent software that shares its name.
Read story & evidence
Google’s Argon can continue a response beyond one request’s output limit. Pydantic AI’s released integration shows what that means for an agent: one answer, several network calls, and two different ways of counting tokens.
Read story & evidence
A new prerelease carries media through Ollama’s llama-server backend, alongside its existing MLX route. Google’s EmbeddingGemma 2 supplies the shared representations; applications still decide what to index and how to search it.
Read story & evidence
Its open workflow engine can keep the procedure, ask a model for bounded judgments and call an agent only when investigation is needed. The useful comparison separates the value of reusable code from the value of the decision model.
Read story & evidence
A new snapshot shows reviewers the system prompt and tool definitions produced by the code. Nine controlled configurations turn changes in the agent’s instructions into something maintainers can compare directly.
Read story & evidence
A new trainer connects familiar datasets to distinct learning recipes for models that refine text instead of only predicting the next token. The gain is less custom integration—and a clearer view of the differences that still matter.
Read story & evidence
Studio’s research mode can draw on search tools you select, alongside the web and its knowledge base. The merged change expands what can reach a report, while leaving a revealing boundary around how the next question is chosen.
Read story & evidence
Two released coding agents now share a status protocol for working, waiting and finished runs. It gives compatible terminals a way to surface the agent that needs attention—without deciphering each tool’s screen.
Read story & evidence
Pi 1.1.0 lets an agent script send images to OpenAI Decisions and receive answers it can use in code. The release expands a practical division of labor: the main model writes the task, a separate call judges a bounded question, and the script chooses what happens next.
Read story & evidence
Strands puts a small decision model between an agent's proposed action and its tool. Browser and document experiments reveal a wider division of labor: models judge, software defines the choices, and escalation can mean another model—or a person.
Read story & evidence
An October 7 change removes background task handles from Goose while preserving concurrent helpers. The distinction matters for anyone whose recipes ask an agent to start work, carry on, and collect the answer later.
Read story & evidence
A new extension brings design feedback into a running agent without another terminal prompt. Its public code exposes the handoff; an author-reported live test carries it through to a canvas revision.
Read story & evidence
A new migration command finds existing setup, previews the move and imports selected plugins. The useful change is less work to try another assistant—with a precise boundary around what travels.
Read story & evidence
The company’s disclosure total has more than doubled since August. Most of the net increase sits in the route without the same external review—a useful distinction when judging what the expanding program delivers.
Read story & evidence
Harbor’s executable tests now fit the ordinary dataset viewer and loading tools. Evaluators can inspect instructions and declared requirements together before choosing which work to run.
Read story & evidence
The experimental history editor can fold an older patch series while leaving a separate working branch alone. Its handling of dependent branches—and some merges—defines the useful new choice.
Read story & evidence
OpenAI’s new event subscriptions give plugin builders a way to describe what should start a job. The useful change is an explicit integration contract for ongoing work, with the app still responsible for getting its events delivered.
Read story & evidence
The coding agent once left MCP to outside extensions. Its new release supplies an implementation, while giving extension authors a shared way to call tools and the ability to replace the defaults.
Read story & evidence
A probability-bearing answer buys more than a label. Local decision models and a public routing experiment now expose the next choice: how much accuracy must the cheaper route preserve?
Read story & evidence
Pydantic’s weekend changes tie a framework, a coding harness and a terminal client to one release process. Set beside OpenAI’s managed Agents API, they reveal a choice that model rankings miss: which parts of the agent your team still has to run.
Read story & evidence
Tasks and TaskFlow are gone from OpenClaw’s main branch. Background execution remains, but plugins lose a shared interface—and some upgrade scenarios still lack a completed proof.
Read story & evidence
OptiLLM stopped treating its bundled provider examples as an automatic fallback. A clean-directory test shows the difference—and why an empty provider list is not the end of a routing audit.
Read story & evidence
OpenWork’s new auth guide and discovery metadata let an agent distinguish starting a workspace from acting as its owner. Permission errors can now name the human handoff instead of inviting another retry.
Read story & evidence
QM now places a mid-run correction where the agent runtime receives it. That small change separates a delivery problem from an agent that had the information and still went wrong.
Read story & evidence
A Headlong review found that helpful citations could overwhelm a small context request—or stop it halfway through. The repair gives optional memory its own limits while preserving the base.
Read story & evidence
Mastra adds a choice after memory-model retries run out. Continuing preserves the unprocessed input, so a long outage can still fill the agent’s context.
Read story & evidence
The replacement for Studio’s reverted sandbox has landed, followed by a Windows Preview. Its promise is conditional: establish what boundary actually ran, and distinguish an unavailable host from a launch that must be refused.
Read story & evidence
Mastra’s HTTP approval flow could miss an Inngest-backed run and then deny its owner. A merged repair restores discovery without treating another user’s run as fair game.
Read story & evidence
Tangle’s move from a large React context to a shared store contains a sharper lesson than a library preference: an agent-facing creation method must not report an object that its owner never accepted.
Read story & evidence
A lean agent build answers Buzz’s packaging problem. The review draws a harder line around which existing configurations it will carry.
Read story & evidence
LangChain’s AI-assisted integration shows why a tool definition needs tests for its position, its caller and its trip through the serializer.
Read story & evidence
Tangle now exposes when a container record was updated. Use it to explain an observation, without declaring an unchanged job dead.
Read story & evidence
Linux tool confinement now leaves the agent’s model connection on the host. The public review shows why the settings file that selects that boundary deserves just as much scrutiny.
Read story & evidence
Headlong’s privacy fix gained a stronger test only after review noticed that the supposedly protected memory file never existed.
Read story & evidence
OpenWork adds a direct, read-only route from a member’s permitted skill catalog to its instructions. The returned total matters as much as the list.
Read story & evidence
Microsoft’s Agent Framework closes a misleading route through delegated tool approval. A child can decide immediately under policy; a person who answers later needs a workflow that knows where to return.
Read story & evidence
TypeSafe's new decision model makes probabilities part of the interface. Ollama's long-requested logprobs already shipped—but reading a token's likelihood and trusting an automated decision are different engineering problems.
Read story & evidence
CrewAI’s new evaluation shortcut needs a trustworthy pointer to completed work. The hard part is deciding which run deserves the file when exports and writers arrive out of order.
Read story & evidence
Pi v0.87.0 lets a builder append an edit to future model context while leaving the original transcript intact. That is useful for a reading assistant—and it is not data deletion.
Read story & evidence
A waiting conversation could survive its own cancellation in OpenClaw’s recovery records. A new repair saves the parent’s stopped state before answering the user—and protects a newer turn from that delayed write.
Read story & evidence
Mastra’s agent-assisted evaluation work gives an irrelevant run a separate outcome. The difficult part is carrying that distinction all the way to storage, averages and the final verdict.
Read story & evidence
Pydantic AI’s new Choices helper builds a menu from data available at run time. The model selects a validated key; the application gets back the record that key represents.
Read story & evidence
Two September 18 changes separate a recoverable interruption from a fresh start: refuse a missing journal, then make the interrupted run visible. Neither promises automatic recovery.
Read story & evidence
Pydantic AI adds a session-level wait between a generated reply and closing the voice connection. The audio consumer still has to tell the truth about playback.
Read story & evidence
An OpenWorker patch attributed to Devin protects a neighboring workspace during a database migration. Its strongest lesson is the assertion about the row that should not move.
Read story & evidence
A live review reported working Linux and macOS isolation. The next day, the implementation was reverted. Studio’s remaining protections make the consequence more specific than “the sandbox is gone.”
Read story & evidence
Hugging Face’s Dataset Viewer can select labelled unanswerable questions before you download a corpus. Keep those labels out of the model’s input.
Read story & evidence
LangChain’s new TypeSafe client gives application code detailed failures and ordinary log messages a smaller view. The engineering lesson lies in the boundary between them.
Read story & evidence
OpenWork reproduced a ten-second approval timeout before the user’s decision reached the engine. The repair gives that decision a separate route through a busy desktop app.
Read story & evidence
Snowflake’s SQL API gives unfinished work a receipt. Save it, check it later, and keep “accepted” separate from “results ready.”
Read story & evidence
An agent-assisted LangChain fix protects a gateway’s free-form arguments. The useful craft is testing what a schema means after another library has translated it.
Read story & evidence
Microsoft’s Agent Framework is changing what its Python HTTP clients remember. A new conversation can still inherit an old login when both use the same cookie jar.
Read story & evidence
A persistent agent needs somewhere to experiment without rewriting the machinery that keeps it alive. Headlong’s systemd deployment draws that line—and its migration shows why the line is harder than a read-only flag.
Read story & evidence
Pydantic AI’s enqueue API lets a worker add context while an agent is running. A September 15 repair makes the closing boundary explicit: the message enters the queue, or the caller gets an error.
Read story & evidence
Kilo’s main branch now enables a shared agent board by default. Its messages can carry findings across a team—but a successful post cannot summon a worker, prove it listened, or stop it.
Read story & evidence
Qwen Code’s workflow API can set one agent’s reasoning effort and remove tools from that step. Those choices also change which saved result a resumed workflow may reuse.
Read story & evidence
Shepherd’s citation checker keeps complete results through a failed review batch. The useful craft lies in deciding what can survive—and what must remain untrusted.
Read story & evidence
Hermes now makes a child wait, kill, or formally hand over background work before it returns—ending one treacherous kind of progress report.
Read story & evidence
Mastra’s agent-assisted feedback work makes identity a useful optional layer—not a reason to lose an anonymous or unresolved record.
Read story & evidence
Pydantic AI’s new Codex provider turns an existing subscription into a typed-agent option—with its authentication and streaming limits in plain view.
Read story & evidence
OpenWork’s merged macOS 14+ preview gives a desktop-driving agent one person-approved window and a short-lived native session—a meaningful boundary, but not an operating-system sandbox.
Read story & evidence
Microsoft Agent Framework now shows how to call Parallel Search MCP without an API key—a useful public-web research path, provided the researcher treats every query, URL, objective, and session ID as data leaving the client.
Read story & evidence
QM’s new admin-login route lets an already authorized administrator open a portal before outbound email exists—but only through a five-minute, origin-bound, one-use handoff that gets checked again at the door.
Read story & evidence
Headlong turns a persistent coding agent’s reorientation into a versioned wake context—runtime SHA, sync time, and a bounded workspace map—so the first step after a pause need not be another pwd / ls ritual.
Read story & evidence
Mastra’s MASTRA_MESSAGE_AUTHOR_KEY lets a server carry a verified sender into stored shared-agent messages—useful for accountability, as long as no one mistakes attribution for authorization.
Read story & evidence
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.
Read story & evidence
Mastra’s LiveKit integration can pass memory.options.readOnly to speculative voice turns, so they read context without leaving unfinished speech or unspoken replies in the thread.
Read story & evidence
Crush’s Hyper Prism work carries the routed model from response headers to a durable turn record—the provenance pattern builders need whenever a router may change what actually served the request.
Read story & evidence
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.
Read story & evidence
Qwen Code's workflow controls are interesting not because they add buttons, but because the runtime now gives retry, delete, cancel, and history one shared answer to “which run is this?”
Read story & evidence
LangChain's beta MCPAdapter carries a server's tool metadata into an agent runtime, giving builders a practical way to pause risky calls for a human—without mistaking a hint for authorization.
Read story & evidence
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.
Read story & evidence
Microsoft Agent Framework’s Copilot-assisted approval repair shows the craft worth stealing: authorize one stable local occurrence, not a provider’s reusable tool-call label.
Read story & evidence
Pydantic AI now carries an Anthropic thinking-block fallback through later turns—but the useful operator move is to expose the loss, then fix the unstable prompt prefix that caused it.
Read story & evidence
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.
Read story & evidence
Tangle sells a drag-and-drop ML canvas. Its current source reveals the harder product: a content-keyed experiment record that a beta AI Sidekick is beginning to mutate—and open nested-graph patches show where that power can lie about success.
Read story & evidence
Qwen Code’s Claude-assisted inbox hardening shows the reusable craft: treat an endpoint and its credential as one capability, then erase both before a child process can inherit them.
Read story & evidence
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.
Read story & evidence
Mastra’s new memory simulator freezes the data-generating boundary, isolates each prompt arm, and makes a same-prompt A/A run expose the noise that a flashy A/B result might otherwise hide.
Read story & evidence
Kilo Code’s public migration endpoint lets a configured server rediscover Claude Code or Codex history it can read, create a Kilo session per source, and make a normal retry a skip instead of a duplicate.
Read story & evidence
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.
Read story & evidence
Qwen Code’s AUTO-mode repair turns an empty MCP permission prompt into a bounded, visibly incomplete policy view—a small interface with a serious security lesson.
Read story & evidence
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.
Read story & evidence
The public code points to an accidental distributed system: durable shared state gave short-lived agents memory, a mismatched grader made the evaluator the real target, and ordinary parser and cloud-permission failures turned accumulated tactics into access.
Read story & evidence
Eight fixes, five public code trails and three closed rooms: OpenAI's repository strongly supports several mechanisms in its Codex usage announcement, but not the reset, the savings percentages or every background worker.
Read story & evidence
Pydantic AI’s public AG-UI adapter now gives a tool-only response an announced assistant-message parent—useful when a frontend rebuilds a conversation from streamed events.
Read story & evidence
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.
Read story & evidence
Pydantic AI has published a durable-execution backend surface for third-party workflow engines—useful when an agent needs recovery without every integration rebuilding the model, tool and capability loop.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
The reusable craft in Headlong’s Docker-broker work is simple to state and hard to fake: validate configuration before a trusted resolver can turn it into host access.
Read story & evidence
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.
Read story & evidence
OpenWorker 0.2.0 adds three security coworkers, but the source reveals something more useful than another scan button: auditable runbooks that separate scanners, model judgment, approvals, and fixes.
Read story & evidence
Portable Computer keeps its model, harness, conversation, and task trail on the user's machine by default, then asks before one step uses the web or a frontier model. That boundary matters more than its vendor-run benchmark.
Read story & evidence
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.
Read story & evidence
Headlong says a persistent agent never sleeps. Its launch-week code shows the harder truth: continuity is a wake clock, a spend policy, one shared life log, and a rule for deciding whether a thought counts as work.
Read story & evidence
CrewAI’s public Claude Code-assisted repair treats a conversation as ordered typed data—not a paragraph to be reassembled—and tests every path that could quietly change who said what.
Read story & evidence
The new StudioBench is designed to make a performance result fail before it makes a flattering headline.
Read story & evidence
A cache becomes reliable when it shares only the reads that belong together—and yields to the live write that does not.
Read story & evidence
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.
Read story & evidence
Microsoft Agent Framework’s preview Foundry Hosting source adds an opt-in that lets an in-flight conversation queue a second input instead of treating it as a lock error.
Read story & evidence
Qwen Code’s agent-assisted daemon patch turns a fragile global preference into a tested per-session record—and offers a durable-state lesson other builders can steal.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
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?
Read story & evidence
Pi's dev branch is turning an agent run into a durable, remotely attachable session—but its most important promise is also the simplest: record the restart point before the model or tool gets to act.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
A public Claude-assisted MCP migration in Hermes Agent shows the durable craft: make a compatibility seam explicit, then test every way an upgrade can lose meaning without crashing.
Read story & evidence
Cloudflare’s public Responses and Messages endpoints give agent builders a choice that generic gateway adapters often erase: keep the provider-shaped request format that the workflow actually needs.
Read story & evidence
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.
Read story & evidence
Pi now sends every built-in xAI model through the Responses API—a useful route for agents that need a deliberate, client-owned continuity plan rather than a model-name swap.
Read story & evidence
Unsloth’s agent-assisted CI repair shows a durable testing move: put a shared fake at the same interface boundary as production, then make the test harness reveal the task that actually failed.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
OpenWork’s public MCP Apps contract gives a small agent interface one useful rule: its UI resource and tool calls stay with the MCP server that supplied them.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
Pydantic AI’s public MCPToolset now bridges FastMCP 3 and 4—but the documented differences are the point of the upgrade plan.
Read story & evidence
CrewAI’s public agent-assisted telemetry change teaches a durable craft: model a run’s lifecycle explicitly instead of guessing the ending from a start event.
Read story & evidence
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.
Read story & evidence
The beta is more than a local-model GUI: it puts training, export, three compatibility APIs, harness-specific adapters, and a model-control plane on one machine—creating a serious test bench for separating the model from the agent that drives it.
Read story & evidence
Pi’s public constrained-sampling API now has a fresher compatibility layer for builders who want strict tool calls without permanently rewriting the schema their application owns.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
The Agent Client Protocol’s public TypeScript SDK gives a client a newSession() promise; a fresh Goose change shows why that reply is a useful readiness boundary.
Read story & evidence
Qwen Code’s newly merged workflow guidance teaches a transferable engineering move: make agent-facing policy executable enough to fail a regression test.
Read story & evidence
Cline’s restored “View Changes” control makes a completed agent turn point to a checkpointed file delta—not just its own verdict.
Read story & evidence
Five client families now accept one Skills-and-MCP package. The first compatibility gap shows why the harder standard begins where this one stops.
Read story & evidence
Pydantic AI now has a Snowflake Cortex provider, but a useful trial starts by checking the selected model’s capability boundary—not by assuming one adapter makes every model equivalent.
Read story & evidence
CrewAI’s agent-assisted telemetry change makes one reusable move: record who drove a process separately from where the process ran.
Read story & evidence
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.
Read story & evidence
OpenWork’s new headless-thread client turns a subtle race into an explicit contract: an agent turn is not finished just because its status looks idle.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
Mastra’s new transient-signal path lets a processor keep a live instruction near the model without quietly turning that instruction into remembered conversation—and its public commit shows coding agents in the work.
Read story & evidence
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.
Read story & evidence
Qwen Code’s opt-in Tool Guard gives managed ACP deployments a small local API that can allow or deny a supported top-level tool call at its final execution boundary.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
Pydantic AI turned several ways a coding-agent workflow can silently do nothing into tested policy checks. The transferable craft is to test the execution graph, not just the agent prompt.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
CrewAI's current source makes a useful correction to the role-playing pitch: a multi-agent crew becomes an operable system only where it carries state, records its progress, and proves what happens after a stop.
Read story & evidence
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.
Read story & evidence
The finish is a split decision: Codex makes filesystem policy travel into capability discovery; Qwen Code makes a fork’s tool gate survive resume; OpenHands and Gemini CLI make narrower but useful controls reachable.
Read story & evidence
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.
Read story & evidence
OpenAI says two context choices lifted GPT-5.6 Sol from 13.3% to 38.3% on the ARC-AGI-3 public set. Codex source shows those “settings” are really a production memory system—and rival harnesses reveal how much of it can be copied.
Read story & evidence
Mastra’s public sandbox-pool patch treats reuse as a recovery problem: clean the worktree, separate credentials, and assume the machine may fail before it can be claimed again.
Read story & evidence
Mastra’s new webSearchTool is deliberately not a generic search client: it selects a provider-native tool from the active model or fails where the provider boundary is unclear.
Read story & evidence
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.
Read story & evidence
The opening call gives Codex a narrow provisional edge for making subagent instruction precedence survive delegation and resume—but Qwen Code, Gemini CLI, and OpenHands each put a different kind of operator control on the track.
Read story & evidence
Microsoft's new framework has migration paths for AutoGen and Semantic Kernel, but its freshest source work makes a more practical promise: carry a caller's intent across an agent boundary without letting it overrule the host that operates the run.
Read story & evidence
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?
Read story & evidence
A fresh cancellation fix draws the line clearly: typed inputs and validated outputs can discipline an agent’s interface, but a long-running run still needs a truthful answer to one operational question—did it actually stop?
Read story & evidence
CrewAI’s new WaitTool gives an agent one narrow capability: let a real external job make progress before checking it again—without pretending that a pause is a status update.
Read story & evidence
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.
Read story & evidence
A fresh Goose provider change adds Claude Opus 5 and adaptive-thinking support; the more consequential choice is still whether that model may act through local tools without asking first.
Read story & evidence
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.
Read story & evidence
A model's next move is shaped by the tool output, trust state, history, and recovery rules a harness hands it—so a bad run is not automatically a bad model.
Read story & evidence
Cline's newest desktop work is not just another client: it moves chat toward a shared Hub that has to keep sessions, capabilities, and approvals legible across surfaces.
Read story & evidence
Mastra's open source says the difficult part of an agent stack is not producing a turn—it is making state, resumption, tracing, and tool authority behave like application concerns.
Read story & evidence
Qwen Code's latest trust-reload work shows what a model-aware coding agent still has to own: workspace authority, session state, tool routes, and a safe way to change the rules while work is running.
Read story & evidence
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.
Read story & evidence
Kilo’s CLI still carries OpenCode in its source tree. Its newest code shows what a fork has to own once it starts routing work among editors, remote sessions, and a cloud service.
Read story & evidence
Qwen Code’s new search path treats a billed, credentialed web request as a tool that must earn its power—not as a convenience setting that quietly inherits an agent’s other privileges.
Read story & evidence
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.
Read story & evidence
Pi's latest accounting patch treats compaction, branch summaries, and tool-result hooks as model work with receipts—not invisible overhead beneath an agent's final answer.
Read story & evidence
LangChain's new reasoning_effort interface lets a builder express an effort choice once across supported chat integrations—provided the selected model profile says that choice exists.
Read story & evidence
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.
Read story & evidence
Hermes' public delegate_task surface can now return a live, local log for each child—useful when a background fan-out needs observation without flooding the parent conversation.
Read story & evidence
A Codex TUI patch cuts duplicate status reads by treating new, resumed, and actively streaming agent threads as different lifecycle states.
Read story & evidence
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.
Read story & evidence
France’s public holiday API gives an agent zone-specific statutory dates—but only a person can decide whether that means a team is unavailable.
Read story & evidence
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.
Read story & evidence
Crush’s agent-attributed MCP recovery work teaches a hard-earned rule: a connection is not back until every capability it advertises is back too.
Read story & evidence
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.
Read story & evidence
Tau is choosing Pi-compatible extension and event shapes, but its public migration code makes a more human promise: a user's old session should have a route into the new system.
Read story & evidence
Tau's public Python extension interface gives a coding agent a place to turn tool completions into a small, inspectable deployment or review ledger.
Read story & evidence
A new Codex TUI change treats an interrupted request as part of the record, then gives the next instruction a clean composer.
Read story & evidence
The new Rust Open Interpreter is openly building on Codex; its public advantage is upstream leverage, not a proven inside track.
Read story & evidence
Hermes and OpenClaw are fixing different failure windows in the same promise: delegated work has to arrive somewhere a person can use it.
Read story & evidence
Crush’s agent-attributed sidebar feature is a useful reminder: delegate the bounded interaction, then inspect the state machine—not just the screen.
Read story & evidence
Géorisques’ public commune endpoint can give an agent a responsible starting checklist—if it never mistakes the list for an address-level verdict.
Read story & evidence
Pi’s OpenRouter fix shows why “OpenAI-compatible” requests still need provider-specific routing details.
Read story & evidence
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.
Read story & evidence
The first two public GPT repositories record a team handoff and a changing release boundary—not a hero commit—from task fine-tuning toward tokenization, inference, and sampling while the training system stayed out of view.
Read story & evidence
QuickJS, TinyCC, early QEMU, and early FFmpeg reveal a repeatable engineering move: find an expensive handoff, collapse it on the common path, and leave a narrow boundary others can build around.
Read story & evidence
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.
Read story & evidence
The project's v0.3.0 source keeps a task's changes beside the working tree as a retained changeset, then makes settlement explicit and one-time.
Read story & evidence
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.
Read story & evidence
Saracroche turns 1,548 compact French call-list patterns into 16.956 million represented numbers, then hands them to CallKit 10,000 at a time. The source explains the design; it does not prove every entry succeeds on a phone.
Read story & evidence
VigiEau’s public API turns a commune or coordinates into the current alert zone, restrictions, and underlying order—useful for a local service that needs to ask what rules apply here, today.
Read story & evidence
The transferable lesson in Saracroche’s AI-assisted iOS work is not “use less AI.” It is to trace every state transition across an extension boundary before delegating a local implementation.
Read story & evidence
OpenWork’s new organization installer bundles the generic installer, the standard desktop artifact, and organization configuration together—making an offline setup path a public product contract rather than a deployment footnote.
Read story & evidence
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.
Read story & evidence
An AI-assisted OpenClaw fix grew into a generation-scoped restart protocol after maintainers tested what happens when an old and live subagent share a session.
Read story & evidence
The /privacy screen now says when a consumer data-control does not apply to an account, instead of making Workspace and enterprise users decode a raw OAuth or tier error.
Read story & evidence
France's official RappelConso data can turn a scanned GTIN into a product-recall match—if the agent checks the lot, date, and government notice instead of treating a name hit as proof.
Read story & evidence
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.
Read story & evidence
From micrograd to nanochat, Andrej Karpathy's public code curriculum advances by exposing one more layer, preserving a trusted answer key, and deleting whatever makes the next edition harder to read.
Read story & evidence
ContextMatrix is today's Builder Work Highlight because it shows an AI-assisted coordination pattern: keep tasks in git, let agents use MCP, and make execution backends prove themselves through signed handoffs.
Read story & evidence
Pi's Daily Story is a project-under-pressure story: the coding agent now makes prompt-cache misses, long-input pricing, and thinking levels visible where builders choose how much context to spend.
Read story & evidence
API Discovery: ADEME's Impact CO2 API gives builders a public way to turn transport, heating, food, and everyday-object emissions into quick agent-readable estimates.
Read story & evidence
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.
Read story & evidence
Ralphy is today's Builder Work Highlight because Alec's repo turns a coding agent into the operator of a reproducible video pipeline, not just a prompt wrapper around media APIs.
Read story & evidence
LangChain's retry middleware repair is a people/context story because the project's public human-in-the-loop work makes one small bug fix read as a guardrail for users trying to stop an agent.
Read story & evidence
API Discovery: DINUM's Ma Cantine API exposes canteens, diagnostics, and declaration data that an agent can turn into a compliance-prep checklist for cafeteria software teams.
Read story & evidence
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.
Read story & evidence
Alexandros Kyriakakis publicly said zerodecimal was built with Claude Code, Ultracode, and Fable 5; the repo is worth studying because the generated arithmetic is surrounded by proof scaffolding.
Read story & evidence
Compact source brief, not the lead: the RNB building API is narrow but useful because it gives agents a public building identifier before they draft local permit, retrofit, insurance, or asset records.
Read story & evidence
Shepherd's 0.3.0 release commit is a Daily Story because Derek Chong did not only ship features; the public release note makes executed safety evidence part of the project contract.
Read story & evidence
Lilian Weng's July 4 map of self-improving harnesses gives builders a constructive middle path: improve the runtime around the model, but keep evidence, permissions, and evaluation legible enough that the loop can be trusted.
Read story & evidence
Shilong Liu's taxonomy widens the self-improvement story beyond harnesses: agents may optimize artifacts, modify the harness, or learn in the model, but each loop needs evidence about what changed and what stayed outside the optimizer.
Read story & evidence
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.
Read story & evidence
Live Log Viewer reads local Claude Code and Codex transcripts, reconstructs session parentage, and turns parallel agent work into a live map without adding a cloud service or database.
Read story & evidence
Codex's July 6 Linux network-attribution fix turns a vague shared-proxy denial into a traceable event tied to the exact exec call and command that opened the connection.
Read story & evidence
The data.gouv.fr catalogue API gives agents a public way to search French datasets, inspect metadata, and find attached resources before they act on a claim about public data.
Read story & evidence
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.
Read story & evidence
OpenWork's source trail shows a desktop app, server, orchestrator, router, file sessions, approval flow, export safety, and single-org deployment policy around OpenCode rather than a thin UI wrapper.
Read story & evidence
Haabe's Mycelium is an open-source Claude Code plugin that was publicly described as built using itself and repo-inspected as a decision framework with receipts, git-stored state, and agent skills.
Read story & evidence
Pi's July 6 commits changed issue analysis from a CI artifact into a staff-triggered, gist-backed session that can be summarized in public and imported back into a local checkout.
Read story & evidence
API Recherche d'entreprises exposes public French company search through text, SIREN/SIRET, geography, NAF, and employee-size filters.
Read story & evidence
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.
Read story & evidence
Timo Haanpaa's Scopewalker MCP is worth studying because an AI-assisted build turns coding standards into read-only measurements an agent can call before it edits.
Read story & evidence
API Associations exposes French nonprofit identity data from the RNA and Sirene sources, giving agents a public way to verify an association before drafting eligibility, grant, or onboarding work.
Read story & evidence
Peter Steinberger's OpenClaw session-management PR turns chat history from a recency list into a lifecycle surface with pinning, archiving, read-only state, and proof screenshots.
Read story & evidence
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.
Read story & evidence
Koushik Sen's KISS Sorcar is not interesting because it uses agents; it is interesting because the public repo turns self-hosting pressure into invariants, worktrees, parallel agents, and reproducible checks.
Read story & evidence
A July 3 Tau PR from Rian Dolphin turns branch summaries into a contributor-facing safeguard: the next branch should remember why the previous one existed.
Read story & evidence
INSEE's API Sirene open data gives agents a public way to check French company and establishment identity, with SIREN/SIRET scope and diffusion caveats close to the source.
Read story & evidence
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.
Read story & evidence
Assembled's open-source 143 project teaches a practical builder lesson: make agent work reviewable by routing it through durable sessions, sandboxes, previews, and normal pull requests.
Read story & evidence
Ben's July 1 revert turns a feature rollback into a useful maintainer story: the project tried a provider probe and model picker, then pulled them back before the dev branch carried the risk.
Read story & evidence
API.gouv's API Adresse page exposes a fully open geocoding source that agents can use to validate French addresses before routing, mapping, or form decisions.
Read story & evidence
OpenClaw added an on-exit cron schedule so a gateway-owned watcher can wake an agent after a watched process finishes.
Read story & evidence
France's API.gouv catalog exposes a DGFiP tax-data API where agents must treat authorization and proportionality as the product, not an afterthought.
Read story & evidence
Pi's latest extension change lets durable session entries carry custom rendering, turning a maintainer's minimal-core stance into visible public work.
Read story & evidence
A Codex commit adds structured send and receive logs for multi-agent communication, making delegation easier to trace without making it today's lead.
Read story & evidence
Hermes replaced a shared approval flag with thread-local state, then paired that control with secret redaction and delegation-budget tests.
Read story & evidence
OpenAI's public Codex usage-reset note reads like a customer-relief post. The public Codex repository shows something more specific: a cleanup across auto-review prompts, subagent delegation, review-time suggestions, and reset-credit visibility, while the usage backend remains outside the public diff.
Read story & evidence
Tau's smallest command change became a public contributor story when an outside branch added /exit and the maintainer followed with contributing rules.
Read story & evidence
Agent Pulse saw OpenCode as a July 1 hardening signal, and the source receipts point to layer cleanup rather than launch noise.
Read story & evidence
API Entreprise gives agents a public map for company checks, but the source also makes the permission boundary impossible to miss.
Read story & evidence
A cluster of OpenClaw commits put scheduled wakes, ACP runtime controls, and browser proxy invocation behind narrower target and scope checks.
Read story & evidence
Two Pi coding-agent commits repaired the visible status and regression-test trail around interactive compaction, keeping context management inspectable instead of silent.
Read story & evidence
The api.gouv.fr catalog records API Geo as an open public geography API with a technical definition, rate limit, WGS-84 coordinates, and GeoJSON support.
Read story & evidence
A public Crush patch moved shell-message persistence behind a session-existence check, turning a disappearing workspace edge case into tested agent reliability work.
Read story & evidence
A Tau documentation rewrite moved the coding-agent project from build-log internals toward a public quickstart, reference, package, and license surface.
Read story & evidence
A public start-guide patch shifted OpenWork's agent-first onboarding away from email signup and toward provisional workspace claim links.
Read story & evidence
A contributor patch moved OpenCode's external served TUI from implicit local assumptions toward explicit ServerAuth headers in its transport configuration.
Read story & evidence
A compact Codex patch makes skills usage instructions depend on model metadata instead of hardcoded model-name matching.
Read story & evidence
A new Codex plugin patch turns marketplace source restrictions into runtime filtering, loading, and cache-refresh behavior.
Read story & evidence
A Hermes Agent contributor patch strips active virtualenv markers before terminal subprocesses can misdirect another project's Python tools.
Read story & evidence
Gemini CLI, OpenClaw, and Hermes all turned ordinary boundary mistakes into explicit control failures.
Read story & evidence
A public Hermes Agent patch by kshitijk4poor removed a process-global session key so command approvals stay attached to the originating session.
Read story & evidence
Mistral Vibe 2.18.0 turns ACP behavior, editor setup, auth cleanup, and fork-session limits into release-visible evidence.
Read story & evidence
Three public Crush commits by Kieran Klukas turned shared config, OAuth refresh, and malformed tool-call state into tested failure boundaries.
Read story & evidence
OpenWork's June 24 code changes make deployment configuration, readiness, packaging, and user-flow proof visible as project maturity work.
Read story & evidence
A public bug report turned an OpenClaw memory-store regression into a doctor-owned migration with tests, vector-row restoration, and explicit proof limits.
Read story & evidence
LangChain and Pi are making model/provider changes easier to inspect before they become hidden assumptions inside agent runtimes.
Read story & evidence
Two OpenCode commits by Shoubhit Dash turned MCP resources from connected-server metadata into tools an agent can list, template, and read with limits.
Read story & evidence
Fresh OpenClaw, Codex, and Hermes changes show agent projects turning speed modes, chat metadata, and worker instructions into explicit runtime surfaces.
Read story & evidence
The public record after the June 4 transition points to Antigravity as the packaged migration and operator surface, while Gemini CLI still carries open implementation repair.
Read story & evidence
Fresh Gemini CLI and OpenWork patches show agent products turning hangs, publish failures, voice quotas, and provider outages into explicit runtime behavior.
Read story & evidence
A Gemini CLI contributor fixed a scheduler starvation path by changing how parallel tool waves yield back to the event loop.
Read story & evidence
Fresh OpenCode, Codex, OpenClaw, and Hermes Agent patches show agent tools turning long-running work into bounded, traceable runtime state.
Read story & evidence
A public OpenCode patch by Kit Langton turns an agent's configured step limit into a user-facing summary moment instead of a silent loop cap.
Read story & evidence
Fresh Codex, Hermes Agent, and Pi patches show agent projects narrowing when external skills, MCP tools, and package surfaces become visible.
Read story & evidence
A public Pi commit by Fred K. Schott added base entrypoints so developers can import a smaller agent or AI surface instead of the whole package.
Read story & evidence
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.
Read story & evidence
A public OpenClaw commit by Jesse Merhi replaced command-approval parsing with a Tree-sitter-backed planner so shell decisions can travel through node and gateway execution.
Read story & evidence
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.
Read story & evidence
Kieran Klukas changed how Crush runs child processes so shell jobs cannot seize the parent session or corrupt the terminal UI.
Read story & evidence
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.
Read story & evidence
A June 15 OpenWork patch turns product documentation into agent tools, making app help a runtime behavior instead of a repo archaeology task.
Read story & evidence
Gemini CLI, LangChain, and Codex landed fresh patches that put agent safety in filesystem checks, type gates, pending-tool waits, and permission-path parsing.
Read story & evidence
A June 15 Gemini CLI fix turns a convenience feature, installing community skills, into a tested filesystem boundary.
Read story & evidence
Fresh Codex, OpenCode, and Pi patches show agent interfaces routing threads, draft sessions, and terminal setup by local context before the user acts.
Read story & evidence
A June 14 Pi contribution makes first-run setup ask the terminal what background it is actually using before choosing a light or dark theme.
Read story & evidence
Fresh OpenClaw, OpenCode, Hermes Agent, and Codex patches show agent tools treating interruption and recovery as runtime work, not edge-case cleanup.
Read story & evidence
Jason (Json)'s June 13 OpenClaw patch turns pending node reapproval from hidden gateway state into CLI guidance an operator can act on.
Read story & evidence
Fresh Crush, Codex, OpenClaw, and OpenCode changes show agent runtimes separating user memory, project context, and sandbox paths before work starts.
Read story & evidence
Mistral Vibe looks mature in release machinery and public feedback channels, but its own contributor guide keeps code contributions outside the main door for now.
Read story & evidence
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.
Read story & evidence
A June 10 Hermes Agent patch by Matt Harris made web search work without a key; a follow-up by Teknium shows the maintenance question hiding inside that convenience.
Read story & evidence
Fresh OpenCode, LangChain, Gemini CLI, Codex, and OpenClaw commits show agent projects tightening the machinery around tools, sessions, streams, and approvals.
Read story & evidence
Aiden Cline's June 10 OpenCode commits turn a permissions bug report into a more interesting design line: parent sessions can set hard ceilings, but subagents keep their own job descriptions.
Read story & evidence
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.
Read story & evidence
The Pi repo shows a different coding-agent bargain: a small terminal harness, a public maintainer culture, and a source-visible insistence that workflows should live in extensions, skills, packages, files, and external sandboxes instead of a swollen core.
Read story & evidence
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.
Read story & evidence
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."
Read story & evidence
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.
Read story & evidence
In January 2006, ACPI maintainer Len Brown folded eleven Linux topic branches into one twelve-parent merge commit. It looked almost comic, pushed Git's own tools to grow sharper eyes, and now reads like a warning label for the agent era: clean integration is not the same as clear accountability.
Read story & evidence
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.
Read story & evidence
Linus Torvalds's first eleven-file commit made content-addressed history the durable core of software collaboration. Twenty-one years later, agents are multiplying branches, worktrees, commits, and pull requests - and forcing source management to answer who acted, why, and who is accountable.
Read story & evidence
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.
Read story & evidence
From an Apache-licensed terminal agent to the non-public shared harness behind Antigravity CLI, desktop, SDK, and Managed Agents, Google's I/O transition is an architecture and governance shift, not a rename.
Read story & evidence
Fresh LangChain, Crush, Gemini CLI, and OpenClaw commits show agent tools turning denial, fallback, routing, and policy drift into explicit next steps.
Read story & evidence
The Rust repo and compiler docs confirm the Trusting Trust shape: modern rustc starts from an earlier rustc binary. The evidence supports an audit question, not an accusation.
Read story & evidence
Fresh Codex and Hermes commits show a practical shift in agent tooling: longer-running work now needs recovery rails, not just more controls.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidence
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.
Read story & evidenceThe newest source-readable trail points away from model mystique and toward the workflows that test, trace, serialize, and maintain agent behavior.
Read story & evidenceAfter 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.
Read story & evidence
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.
Read story & evidenceRecent 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.
Read story & evidenceRecent Codex and Hermes Agent changes show coding agents turning goals from chat commands into durable metadata, resumable session state, and queued work control.
Read story & evidenceRecent 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.
Read story & evidenceFresh 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.
Read story & evidenceThe 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.
Read story & evidenceThe new problem is not just squeezing a bloated context window. It is preserving the right tail, marking what was compressed, and making the session recoverable when the cut goes wrong.
Read story & evidenceThe 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.
Read story & evidenceThe shift is no longer just context compression; summaries are being promoted into durable runtime objects with IDs, policies, UI affordances, and maintenance workflows.
Read story & evidenceThe 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.
Read story & evidenceSubagents used to be the shiny feature. Now the harder question is whether the runtime can choose the right specialist, hand work off cleanly, recover when the chain gets messy, and prove it made the right call.
Read story & evidenceThe 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.
Read story & evidenceThe next contest is not just who gets the biggest context window. It is who decides, with discipline, what survives when the window starts to fill.
Read story & evidenceThe 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.
Read story & evidenceThe next battle is not just who gets the biggest context window. It is who can keep a task alive when the window trims, the app reloads, the session name drifts, or the agent gets interrupted mid-run.
Read story & evidenceThe 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.
Read story & evidenceWhat used to look like a boring permissions menu is starting to behave like a gearbox. Across agent CLIs, “plan,” “review,” “yolo,” and model-shaped tool policies are becoming distinct runtime states with different prompts, tools, and output contracts.
Read story & evidenceThe 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.
Read story & evidenceA year ago, “web fetch” in an agent might have meant little more than “grab the page and hand the text to the model.” Recent code in OpenClaw, Gemini CLI, and Crush suggests that era is ending. In these projects, the web tool is starting to look like a trust boundary: part scraper, part sanitizer, part permission system, part anti-SSRF guard.
Read story & evidenceThis 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.
Read story & evidenceThe new contest in coding agents is not just who has the slickest prompt loop. It’s who can let an AI touch your machine without making that feel reckless. This week’s code points to an increasingly architectural answer: move sandboxing closer to the runtime itself.
Read story & evidenceThe 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.
Read story & evidenceThe biggest shift in coding agents right now is not that they can spawn helpers. It’s that those helpers are starting to look less like disposable tool calls and more like employees with titles, access badges, and a reporting line.
Read story & evidenceThe 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.
Read story & evidenceThis 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.
Read story & evidenceThe 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.
Read story & evidenceTerminal 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.
Read story & evidenceTerminal 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.
Read story & evidenceTwo 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.
Read story & evidenceAgent 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...
Read story & evidenceToday’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...
Read story & evidenceElicitation 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...
Read story & evidenceGitHub’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...
Read story & evidenceGemini 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...
Read story & evidenceCodex 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...
Read story & evidenceGemini 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 (...
Read story & evidenceThe 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...
Read story & evidenceTheGitReporter — 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...
Read story & evidenceTwo 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...
Read story & evidenceOn 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...
Read story & evidenceYou’ve reached the beginning of the archive.
Back to the latest stories ↑