248 liked tweets from the past week. June 1 through June 7, 2026. Here’s what I pulled out of the noise, organized into the themes that kept recurring.
Six things to take away
-
Validation belongs inside the loop. Don’t hand the agent’s output to a human and let the human catch bugs. Run typechecks, lint, tests, builds, and browser checks before a human ever sees anything. Push failures straight back to the agent. The human’s job shifts from “find bugs” to “review intent.” [1] [2]
-
Disposable verification harnesses are a thing now. Claude Code can generate a throwaway script that extracts every technical claim from a draft, maps them to files in the repo, and flags contradictions. You describe the verification in natural language, it writes the code. [3] [4]
-
Cloud agents are infrastructure, not chatbots. Once you move an agent off a laptop and onto a server, you’re building a distributed system. Pod lifecycles, stream rewinds, state isolation, stale output during retries - that’s the real product. [5] [6]
-
Skills are a supply chain problem. Agents pull skills from APIs and repos. Skill PRs need security scanners the same way code PRs do. [7] [8]
-
Stop giving agents generic prompts. Give them evidence. The failing curl output. The log excerpt. The trace. The database row. Specificity beats instruction. [9]
-
Work memory is shared state, not a personal archive. It tracks what’s current, what already failed, and what a different agent can safely build on. [10] [11]
The loop, again
Without backpressure, here’s what happens: the agent writes code, hands it to you, you spot the broken import, tell the agent to fix it, it fixes it, hands it back, now the test fails. Repeat.
With backpressure, the harness runs first. Typecheck, lint, tests, build, logs, browser rendering. The agent sees the failures and fixes them before you ever get involved. You only review intent - “is this what I wanted?” - not correctness. [1]
Last month’s notes were about running multiple agents. This week it’s about generating a disposable workflow for a single strict task. The newer Claude Code approach: describe a blog post verification task, and it writes a JavaScript harness that extracts claims, maps them to source files, runs checks, and reports contradictions. [3]
One framing I liked: a workflow is a team. You have planning, fleet execution, and adversarial review as separate roles. [12] Dynamic workflows shine when a task genuinely needs all three. If your verification procedure is less precise than running three shell commands, though, just run the commands.
Cloud agents as distributed systems
Peter Pang wrote up the Cursor lessons from moving their desktop agent to the cloud, and it’s worth reading carefully. [5]
The core insight: once the loop leaves the laptop, you’re dealing with distributed systems problems. Who owns machine state? How do pods recover? How do retries interact with streamed output? If you don’t handle streaming and retries carefully, the client sees stale partial code during recovery, and the whole experience breaks.
Cursor uses Temporal to decouple the agent loop from the VM itself. Pod lifecycles get managed separately. It’s not a chatbot on a server. It’s infrastructure.
Skills as packages
Hiten Shah had a good framing: capture how your best people work, compress it into reusable patterns. [13]
Vercel’s skills.sh API is the concrete version of this. Over 600,000 searchable skills, project-scoped OIDC auth. [7] [14]
But here’s the problem. If skills act like packages, they need security reviews. The real risk isn’t “bad markdown exists in a repo” - it’s autonomous agents acting on hijacked instructions. NVIDIA’s SkillSpector scans for exactly this: hidden instructions embedded in skills, context leakage paths, shadow command triggers. [8] [15]
Evidence over theory
Agents fail in a specific pattern: they read source code, build a theory about what’s wrong, and act on the theory. The fix is to skip the theory and hand them evidence instead. A failing test output. A trace. A request payload. Exact command output. [9]
PostHog’s Autoresearch is the cleanest example I’ve seen. They gave an agent slow production queries and the query-engine source code. Let it run overnight with a fixed time budget. It found a fix for a three-year-old performance bug - 11% improvement. That’s the right shape for an agent task: real production artifact, narrow source context, fixed time, measurable result. [16]
Memory as shared state
Last month’s links treated memory as a personal archive - saving things for later recall. This week’s links treat it differently. Memory is work state.
Agents need to compress their work into state that other agents can trust. [10] Mem0 positions memory as a first-class component alongside tools and coordination, not as an afterthought. [11] [17]
Quarq posted 98.2% on LongMemEval for continual learning. [18] GBrain builds an agent-native knowledge graph over markdown with nightly synthesis runs. [19]
The distinction that matters: a personal archive answers “what did I save?” Work memory answers “what is safe to act on right now?” If two agents retrieve conflicting versions of the same plan, you have drift, and everything downstream is suspect.
Tools below the surface
These are the less visible tools - the ones sitting below browser automation, dealing with page maps, runtime cost, output compaction, local model routing, and interruption channels.
Hyperbrowser’s /web command generates a web.md map of any site, which agents can then navigate from. [20] [21] Browser Use built custom runtimes to cut cold-start times and per-browser-hour costs. [22] [23]
RTK filters and truncates shell output before it reaches the model. Someone reported saving 2.5 million tokens across their coding agents in two weeks with it. [26] [27]
API for Cursor exposes Composer models to other agents through a local endpoint. [24] [25] Razorpay shipped a CLI alongside their MCP - humans get dashboards, agents get CLIs. [28] [29]
Peter Steinberger’s sag tool does something I’ve been wanting: lets the agent interrupt you when it gets blocked. 1Password prompt, release gate, whatever. [30] [31]
Models and evals
NVIDIA dropped Nemotron 3 Ultra. 550 billion total parameters, 55 billion active, hybrid Mamba-Transformer MoE architecture, million-token context window. [32] [33] MiniMax M3 posted strong numbers on SWE-Bench Pro and Terminal Bench. [34]
Liquid’s LFM2.5-VL Extract pulls structured JSON out of images. [35] [36] Nemotron 3.5 ASR handles streaming speech recognition across 40 languages with latency you can dial from 80ms to 1 second - useful for voice agents. [37]
Anthropic published a warning worth reading: remote MCP servers can change their behavior after you approve them, and persistent context increases the blast radius when they do. [38]
Agent Arena takes an interesting approach to evaluation - they score live agent sessions instead of static prompts. The argument is that static prompts hide failures that only show up in loops, tool interactions, permission handling, and steering. [39] [40]