Microsoft Research and top Chinese university researchers introduced a general-purpose runtime for long-horizon agent reasoning
essential for AI system architects deploying autonomous developers, Claude Code workflows, and persistent agentic loops
monolithic LLM prompts fail as task horizon expands: unmanaged agent loops suffer from state drift, context saturation, and unrecoverable execution errors
their unified agentic runtime paradigm replaces single-prompt generations with an executable harness, self-improving loop, and stateful graph architecture
four core components of the master agent stack:
1. Context Harness Layer
isolates execution environments, manages AST memory state, and enforces tool boundary guardrails
2. Persistent Loop Layer
evaluates intermediate execution feedback to auto-retry failed tool steps without developer intervention
3. Graph Orchestration Layer
routes multi-agent sub-tasks across specialized search, coding, and verification nodes
4. Checkpoint State Merge
consolidates parallel sub-agent outputs into verifiable PR commits before task completion
unifying harness, loop, and graph engineering transforms non-deterministic language models into verifiable production systems
Read the complete breakdown in the article below ↓
matt retweeted
Stanford researchers did it again.
They just built the agent-native version of Git.
When an agent works on a longer task, the run builds up a lot of state.
This includes files edited/created, a dev server, a database, installed packages, KV cache, etc.
Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine.
The tests start failing, and the run goes off track, although everything through step eight was correct.
By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context.
The other options are a person stepping in to redirect it or restarting the whole run from step one.
That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway.
The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log.
It records what the agent said and which tools it called, but not the live state underneath.
That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log.
Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache.
Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log.
Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run.
Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files.
Going back to a previous step is then a single call that forks from that commit and continues from the exact state.
The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again.
Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed.
In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness.
Not everything is reversible though.
Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance.
Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires.
They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%.
It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time.
If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run.
Shepherd Repo: github.com/shepherd-agents/s…
(don't forget to star it ⭐ )
That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change.
I wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur.
The article is quoted below.
MICROSOFT QUIETLY BUILT ONE MEMORY MODULE THAT PLUGS INTO ANY AI AGENT AND CUTS ITS CONTEXT BY UP TO 100X
no retraining. no task-specific redesign. you just plug it in
Microsoft's insight: agents don't need to remember what happened. they need the knowledge pulled from it - the facts and the reusable skills, not the raw logs
so PlugMem stops storing history. it compiles experience into a knowledge graph, then feeds the agent only what matters
the result:
> up to 1-2 orders of magnitude fewer tokens
> highest decision-utility per token of any system tested
> one unchanged module beats task-specific memory on chat QA, multi-hop search, and web agents
more memory was never the answer. better memory is - and Microsoft just shipped it as a plug-in
bookmark this. the agents that win won't remember more, they'll remember smarter.
matt retweeted
Microsoft found that giving an agent more memory can make it worse. The fix is changing what you store
The paper is PlugMem, from Microsoft Research and UIUC. The failure is plain: history piles up, retrieval drowns in it, and the agent spends its context wading through transcripts for the one line that mattered.
Human memory does not replay events either. It keeps the facts and the skills pulled out of them.
So the memory writer stops saving conversations and saves two record types.
A fact is a stable statement. Deploys go through GitHub Actions, never by hand.
A skill is a reusable procedure. On a failed deploy, read the Actions run before touching production.
Stored that way, one general-purpose module beat memory designs built for specific tasks, across three of them, on fewer tokens.
The metric is decision-relevant information per token of context, not how much you managed to keep.
Bookmark this
matt retweeted
“MemHarness Memory Is Reconstructed, Not Replayed”
Most memory agents retrieve old experiences and paste them straight into context, even when the current state no longer matches.
This paper makes memory adaptive by having the agent critique and reconstruct retrieved memories before acting.
Trained end-to-end with GRPO, MemHarness turns memory from copied context into state-aligned guidance, beating pure RL and static memory baselines with stronger OOD robustness.
You can read more here:
alphaxiv.org/abs/2607.28272
matt retweeted
New Meta Paper.
Code optimization looks like an easy extension of reinforcement learning: reward correct programs, then give extra credit to the faster ones.
This paper shows why that recipe usually fails.
Says that code optimization requires co-designing tests, timing infrastructure, rewards, and GRPO.
Runtime is a noisy, sparse signal, and small flaws in the tests, sandbox, reward, or GRPO update can make the model barely faster while also hurting correctness.
The authors rebuild the entire feedback path: larger optimization tests, a calibrated remote execution service, problem-relative ranking against human solutions, correctness-gated binary rewards, and GRPO changes for noisy zero-advantage batches.
They stabilize GRPO by sampling more solutions per prompt, enlarging batches, dropping group variance normalization, and discarding stale timing data.
Qwen 2.5 7B moved from 18.0% to 31.3% at the top-50% speed threshold only after the full timing pipeline was rebuilt.
– arxiv. org/abs/2607.25970
Title: "Reinforcement Learning for Code Optimization"
matt retweeted
"Metis: Memory Foundation Model"
Most AI agents still use memory as an external RAG-style module, so the model retrieves old text instead of actually remembering.
This paper makes memory native to the Transformer. So past interactions are compressed into dynamic layer states and read through memory attention during normal forward passes.
The model weights stay frozen at inference, but its memory state updates without gradients, giving the model persistent memory inside the backbone.
Still early and lossy, but this is yet another paper with a big step toward agents that remember natively instead of outsourcing memory to a database.
matt retweeted
🚨 A new study shows that chain-of-thought information does NOT capture all the LLM reasoning. Some of the AI governance implications of this invisible reasoning:
The study defines "invisible reasoning" as the consequential computation that occurs within an AI model's internal latent representations but leaves no interpretable trace in the output tokens.
The study calls these semantically irrelevant tokens "filler tokens." They carry no information about any particular problem or answer, but may still act as procedural cues during AI reasoning.
When the AI model's reasoning is not expressed through an interpretable chain of thought but is only present in internal latent states, this has direct implications for AI explainability, transparency, auditing, and safety efforts.
- How do you comply with baseline transparency and explainability requirements when an AI model's chain-of-thought does not reflect the real reasoning behind the output?
- Can existing auditing methods properly address these meaningless but procedurally helpful "filler tokens"?
As AI capabilities continue to saturate benchmarks (and AI models have started to escape testing settings and roam the internet...), the possibility of "invisible reasoning" should be further investigated and acknowledged as an incremental risk.
Congratulations to the paper authors, @vatsalbaherwani, @tomgoldsteincs & @PandaAshwinee!
👉 Download the paper below.
👉 I've added this paper as the 14th recommended paper of our AI Ethics Paper Club (you can join it for free below).
matt retweeted
Someone published a cleaner version of the self-improving AI architecture.
7 steps. One loop. The agent teaches itself.
Most AI systems are frozen the moment you stop updating them. New patterns emerge. Better workflows appear. Your agent never sees them unless you manually find, read, and install each one.
This architecture closes that gap.
Here’s how the loop works.
Scout scans GitHub continuously for new repositories worth learning from. Filter removes the noise before any model wastes compute on it. Only relevant repositories move forward.
Extract pulls out reusable workflows and structures them for the next stage. Score validates each workflow against objective criteria. Quality gate before anything gets built.
Generate converts the validated workflow into a standardized Agent Skill package ready to deploy. Review puts a human in the loop before anything ships. Automation proposes. Humans approve.
Publish adds the approved skill to the library permanently.
Then it compounds.
More skills mean richer context. Richer context means better discoveries. Better discoveries mean stronger skills added to the library.
Then the loop starts again.
Today, software. Tomorrow, experience. Build the loop once. Let it learn.
The architecture is in the image.
matt retweeted
major price cuts today:
*80% drop for GPT-5.6 Luna, now $0.20 per million input tokens and $1.20 per million output
*20% drop for GPT-5.6 Terra, to $2/$12
*GPT-5.6 Sol gets Fast mode in the API, up to 2.5x the speed for 2x the price, same intelligence
matt retweeted
your agent is not a loop
the loop is the smallest part of the system
LOOP vs GRAPH vs HARNESS ENGINEERING
most teams still debug all three as one prompt
that is why every agent failure feels random
LOOP ENGINEERING
controls repetition
turns retries budgets evaluators exits no progress
when the run never stops the loop is broken
make long running work survive crashes and restarts
→ github.com/temporalio/tempor…
GRAPH ENGINEERING
controls topology
nodes edges state branches cycles joins checkpoints
when the agent reaches the wrong step the graph is broken
make state and branching explicit
→ github.com/langchain-ai/lang…
inspect the topology without asking another model to explain it
→ github.com/networkx/networkx
HARNESS ENGINEERING
controls reality
tools permissions memory sandboxes evals traces humans
when the agent touches the wrong thing the harness is broken
isolate generated code and tool execution from the host
→ github.com/e2b-dev/E2B
put an eval gate before every model or prompt change
→ github.com/openai/evals
keep one trace across every node model and tool call
→ github.com/open-telemetry/op…
without loop engineering it never stops
without graph engineering you cannot see why
without harness engineering it can touch anything
the prompt is inside the loop
the loop is inside the graph
the graph is inside the harness
the model is the smallest box in the system
debug the layer that owns the failure
save this before the next agent rewrite
// The agent is its own best speculator //
Agents spend a large share of wall-clock time waiting on tool results. Speculation hides that latency by predicting and pre-executing the next call, but external draft models and cached traces are modeling a different policy, so they miss too often to help.
New research from UC Santa Barbara and LinkedIn unifies both roles in one model. It runs in agent mode to solve the task and in speculator mode to predict its next tool call from a partial trajectory, fully reusing the prefix KV cache.
Joint agent-speculator reinforcement learning derives speculation targets from the agent's own rollouts and alternates updates between the two modes, which keeps dual-mode training from degrading task success.
Next tool-call Hit@1 rises from 44.1 to 61.2 for Qwen3-4B and from 48.9 to 66.3 for Qwen3.5-4B, with agent task success preserved.
Paper: arxiv.org/abs/2607.25816
Learn to build effective AI agents in our academy: academy.dair.ai/
matt retweeted
Kimi K3 can now be run locally! ✨
The 1-bit model retains ~78.9% accuracy after we shrunk it from 1.56TB to 594GB (-62% size).
Run on a Mac Studio + 128GB RAM device.
Kimi K3 is the strongest open model to date.
Guide: unsloth.ai/docs/models/kimi-…
GGUF: huggingface.co/unsloth/Kimi-…
Introducing Kimi K3: Open Frontier Intelligence
🔹 2.8 Trillion Parameters, 1 Million Context, Native Multimodal
🔹 Kimi Delta Attention enables up to 6.3x faster decoding in million-token contexts
🔹 Attention Residuals deliver ~25% higher training efficiency at <2% additional cost
🔹 Built for long-horizon agentic coding and self-evolving workflows
Kimi K3 is now live on on Kimi.com, Kimi Work, Kimi Code, and the Kimi API.
Open Weights by July 27, 2026.
🔗 API: platform.kimi.ai
🔗 Tech blog: kimi.com/blog/kimi-k3
matt retweeted
⚡ UPDATE — The HAWK team has withdrawn its post-quantum digital-signature scheme from NIST’s standardization process after confirming #Anthropic's key-recovery attack sharply reduced its security margin.
NIST now lists HAWK as withdrawn.
Read the updated story: thehackernews.com/2026/07/cl…
matt retweeted
Anthropic's decline continues.
Following the release of Kimi K3 on July 16, Anthropic’s implied pre-IPO valuation is estimated to have shrunk by approximately 13.1%, representing a decline of about $126.42 billion from its last confirmed valuation and about $531.20 billion from its implied peak of $1,369.78 billion.
Dario is probably worried that if he doesn't get the Trump administration to regulate his open-weight competition now, nothing will be left by the time the company goes public.
matt retweeted
🚨A los arquitectos no les va a gustar esto.
Alguien acaba de lanzar como código abierto un editor completo de edificios en 3D que funciona íntegramente en tu navegador.
Sin AutoCAD. Sin Revit. Sin licencias de 5.000 $ al año.
Se llama Pascal Editor.
Está desarrollado con React Three Fiber y WebGPU, lo que significa que renderiza directamente en tu GPU con un rendimiento casi nativo.
Esto es lo que incluye:
→ Una jerarquía completa de edificios, plantas, muros y zonas que puedes editar en tiempo real.
→ Una arquitectura de tipo ECS donde cada objeto se actualiza mediante sistemas acelerados por la GPU.
→ Gestión de estado con Zustand y funciones de deshacer/rehacer integradas.
→ Frontend con Next.js para desplegarlo como una aplicación web, sin necesidad de instalar software de escritorio.
→ Seguimiento inteligente de cambios: solo vuelve a renderizar lo que ha cambiado, no toda la escena.
Y aquí viene lo más impresionante:
Puedes apilar, aislar o separar plantas individuales del edificio. Seleccionar una zona, mover un muro o modificar una losa, todo en 3D y directamente desde el navegador.
Los estudios de arquitectura pagan más de 50.000 $ por licencia para software BIM que ofrece este flujo de trabajo.
Esto es gratuito.
100 % de código abierto.
matt retweeted
Today we’ve raised $52M Seed and we are announcing the public launch of S2.1 Pro.
>It can clone a voice from 5 seconds of audio
>2x faster than Cartesia & 1/6th the cost of Eleven Labs
>most expressive model with word level control over emotion, intonation, pacing etc
We support frontier AI companies including HeyGen, LiveKit, Retell, Sanas, and OpenArt all run our model in production.
If you're a business and we can't cut your voice AI costs by 50%, we'll give you 1 year of Fish Audio for free.
Book a demo: s.fish.audio/tmapke
To celebrate our first birthday, we'll give you 1 month of S2.1 Pro for free. Like, retweet, and comment “Fish” to get it.
We quietly released the open-source Codex Security CLI, but Hacker News found it before we had a chance to share it here...
You can now use it to scan repositories, track findings across runs, verify fixes, and add security checks to CI/CD.
This is an early release, and we're listening to your feedback as we continue improving it.












































