matt

let's do

[matt @berryhill_dev]

The harness is part of an agent’s behavior—not packaging.

It decides what the agent can see, do, retain, survive, and optimize for. I use six questions to catch training-to-production mismatches before runtime.

https://t.co/OR8jZ9L4Bl

#AIAgents #AIEngineering

[matt @berryhill_dev]

Reasoning depth is a routing decision, not a model default.

Give each traffic class a token ceiling, latency budget, accuracy floor, and fallback. Then make adaptive compute beat a fixed-budget control before promotion.

https://t.co/j1SOBNS5EO

#AIAgents #LLMOps

[matt @berryhill_dev]

An agent can finish its task and still leave the next agent unable to start.

Treat handoffs as a two-sided contract: verify predecessor exit evidence against successor entry conditions before admission.

https://t.co/qlQqSKWM5e

#AIAgents #MultiAgentSystems

[matt @berryhill_dev]

A fluent plan is still just a story until reality gets a veto.

The useful pattern: build an executable model, replay it against every observation, commit one bounded action, and revoke authority on the first mismatch.

https://t.co/SzUoq8rdg2

#AIAgents #AgenticAI

[matt @berryhill_dev]

“Near-optimal” is not a deployment claim.

Before a result enters a roadmap, keep six fields attached: objective, comparator, access, precision, success, and resource.

https://t.co/Uc6SMUqVWW

#QuantumComputing #TechStrategy

[matt @berryhill_dev]

Confidence is a hypothesis about where agent errors live—not a license to spend a scarce human audit budget.

Before promoting a confidence-ranked review policy, make it beat an independent control on your own traces.

https://t.co/eSD8kDHGYH

#AIAgents #LLMOps

[matt @berryhill_dev]

Valid JSON proves shape, not truth.

Before an AI extraction becomes accepted knowledge, require four things: evidence, provenance, policy gates, and a reversible path back out.

https://t.co/P5Fcv5cKeZ

#AIAgents #AIEngineering

[matt @berryhill_dev]

Static reservations assume an agent’s service graph is known before execution. Dynamic calls break that assumption.

Reserve what’s known, expire stale holds, and revise capacity as the graph reveals itself.

https://t.co/FGbjylPgdm

#AIAgents #AgentOps

[Vladimir Bayandin @vovudebosh]

🚨 NO CLIENTS? 6 MONTHS BUILDING, STILL $0 REVENUE.

THE PROBLEM WAS NEVER THE PRODUCT — IT WAS SALES.

DROP YOUR LINK: THIS AI FINDS YOUR BUYERS, WRITES THE EMAILS, BOOKS THE CALLS.

$30 FREE CREDITS, ONLY 9 LEFT — GONE TONIGHT 👇

https://t.co/uw2Gj6xaNS

[marfin @marfinxx]

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 ↓

[Akshay 🚀 @akshay_pachaar]

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: https://t.co/uUIS57te6g

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

[matt @berryhill_dev]

TRAJDEBUG makes a useful point: the last wrong step may only be where an agent failure becomes visible.

Trace the earliest consequential error through propagation, resolution—or persistence—and terminal impact.

https://t.co/kuDC638VKE

#AIAgents #AgentOps

[matt @berryhill_dev]

OWASP’s 2026 GenAI guidance is useful. Treating “OWASP-aligned” as timeless is not.

Pin each AI security control to the exact guidance version, preserve the source, and reopen review when it changes.

https://t.co/o264fMi591

#AISecurity #AgentOps

[NO1ennn @N01ennn]

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 @berryhill_dev]

Agents need a compiler before the control plane.

Compile natural-language intent into explicit capabilities, bounded policy searches, isolated tests, and a deliberate production-admission decision.

https://t.co/SgiGSrjJyz

#AIAgents #AgenticAI

[matt @berryhill_dev]

Voice agents need a different reliability test.

Track intent across Capture → Transcribe → Restructure → Correct → Reason → Act. When a constraint disappears, fix the stage that lost it—not the model downstream.

https://t.co/WYLbUjId4u

#VoiceAI #AIAgents

[matt @berryhill_dev]

@coscosmico Right. A skill library without performance feedback becomes a museum of assumptions. Runtime evidence should strengthen, revise, or retire skills based on what actually worked.

[matt @berryhill_dev]

@coscosmico Same. The answer is only one output; the trace shows whether the system used current evidence, stayed within its authority, and changed state safely. If the path fails review, the run failed even when the answer happened to be right.

[matt @berryhill_dev]

A correct final answer can still hide a bad agent run.

Component tests miss stale evidence, widened authority, unsafe state changes, and broken handoffs.

Before deployment, require component passes and trajectory evidence.

https://t.co/BakGXwkXjA

#AIAgents #AgentOps

[matt @berryhill_dev]

@coscosmico Exactly. Parallelism has to buy something measurable. If agents touch the same state or nobody owns the final behavior, the extra activity is usually coordination debt disguised as speed.

[matt @berryhill_dev]

Two coding agents can produce more activity and less working software.

In CooperBench, agents averaged 30% lower success when working together. A clean merge can hide broken behavior.

Make each agent earn its place.

https://t.co/2uYJfeWYaX
#AIAgents #CodingAgents

[matt @berryhill_dev]

@coscosmico That's the distinction. Reflection can suggest a patch, but promotion needs an independent gate that checks the evidence and reruns known-good behavior. Otherwise self-correction is just self-authorization with better branding.

[matt @berryhill_dev]

Reflection can propose an agent correction. It cannot authorize one.

Treat the revision as untrusted state. Promote it only when relevant evidence exists, adjudication says promote, and known-good behavior still passes.

https://t.co/XqXLKA8Ek8

#AIAgents #AgentOps