#agents

June 2026 research stopped treating an agent's skills and tools as a fixed library and started co-optimizing them with the policy via RL.

June's research reframes context management: the discard step is now where both agent quality and safety quietly leak.

Mid-2026 data keeps pointing the same way: bounding an agent's loop beats unleashing it. Turn limits and budgets buy more than a bigger model.

This month's agent tools made spawning parallel coding agents trivial. The constraint moved to the merge decision—and that doesn't parallelize.

Runtime authorization — intercepting tool calls before they execute — is becoming the real security boundary for agents, and a standard is forming fast.

Frontier models now beat the human baseline on OSWorld-Verified — but the benchmark just got rebuilt, and the architecture quietly shifted off pixels.

New research says self-correction fails because of the role label on the claim, not the claim's content. The fix is structural, and cheaper than you think.

Recent work shows a single agent leaderboard number is wrong three independent ways: it's noisy, it's overfit, and the judge measuring it is unreliable.

A June 2026 wave moves the store/evict/retrieve decision from heuristics to a trained policy, and pushes consolidation into an offline sleep phase.

Once agents got long-term memory, a one-time prompt injection could survive across sessions. Mid-2026 research shows both the attack and the defense moving up the stack.

June 2026 mainstreamed always-on agents that listen to event streams instead of prompts — and that one change breaks the trigger, trust, and latency models all at once.

A June 2026 wave of papers shows pruning beats full context on accuracy and cost — and that eviction is becoming a deterministic, cache-aware system, not a summarize call.

Agent skills are an executable supply chain that runs with your agent's full privileges — and the first wave of benchmarks shows our defenses see only half the attacks.

Recent work turns skills, harnesses, and context into objects you can search over and benchmark — optimizing the English around a frozen model instead of the model.

Frameworks are quietly replacing JSON tool calls with generated code. That collapses turns and tokens — and pushes isolation down to the single call.

A new survey and Microsoft's BUILD 2026 release both landed on the same idea: agent capability is leaving the model and moving into the harness.

OpenAI killed its visual Agent Builder the same week Google shipped first-party skills. The agent capability layer just consolidated.

New benchmarks measure calibrated refusal and premature self-stops, and the data says agent confidence signals are broken. Here's how to engineer around it.

In ten days of June 2026, agents got their own budget, their own permission manifest, and their own credentials. The agent is now a principal, not a feature.

Agent RL's bottleneck moved from data to reward to the environment itself. The newest research tries to take humans out of environment-building entirely.

Anthropic and OpenAI independently shipped internal data agents and reached the same conclusion: discovery beats generation, and structure beats access.

A wave of mid-2026 research stopped trying to make the model cheaper and started compressing the agent's own trajectory — at the observation, action, and skill level.

Three late-May 2026 papers attack the agent loop itself — compiling it into weights, speculating through idle time, and letting agents rewrite their own source.

Late May 2026 made parallel fan-out the agent's main scaling axis — orchestration moved into code, tests became the gate, and the meter started running.

MCP went stateless, a wave of coding-agent RCEs landed, and a new benchmark measured reward hacking — the three properties that make an agent useful all became liabilities.

May 2026's skill-library research shows agents can now accumulate reusable capabilities, but retrieving and adopting them is harder than generating them.

The week of May 19 separated the agent loop from tool execution. Whoever hosts the loop now owns your latency, reliability, and lock-in.

New work argues agents are measured wrong: accuracy keeps climbing while consistency, robustness, and predictability barely move. The fix is architectural.

The agents scaling fastest in mid-2026 share one trait: their output lands in a column a machine can check. The verifier, not the model, is the moat.

Recent papers disagree on whether to reward agents per-turn or only at the end — and the answer reveals where RL for agents is actually headed.

STATE-Bench, DeepSWE, Agent Island, SWE-bench Live: a wave of new evals exposes how much the old leaderboards were inflating.

Mid-May 2026 quietly shipped the operations layer for agents — versioned environments, runtime drain, behavior-based evals, portable skills.

Skill cards, self-hosted sandboxes, MCP tunnels, computer-use verifiers, and a Five Eyes warning all landed in twenty-one days. The boring perimeter around capable agents finally has shape.

Twenty minutes of tabs vs. five minutes of prompt. The traditional web wasn't designed for humans — it was designed for mice. The agent-native web is quietly dismantling the parts that never made sense.

Six-hour agent runs are now real. The harness — checkpoints, durable state, recovery — matters more than the model. A field guide to the long-running pattern.

Anthropic just shipped 10 financial services agent templates. The interesting part isn't the templates — it's the three-layer architecture quietly becoming the standard for enterprise agents.

Anthropic shipped a lot on May 6 — Managed Agents updates, Dreaming, Outcomes, Multi-agent Orchestration, and a SpaceX partnership. The signal-to-noise filtered down to five things that change how you build.

Langfuse got acquired by ClickHouse. Helicone hit maintenance mode. OpenTelemetry standardized LLM tracing. The observability stack for agents reshuffled in three months. Here's what it looks like now.

Vibes-based scoring is finally dying. Trajectory eval, rubric eval, golden replay, and the test pyramid that production agent teams actually run.

Deep dive into voice agent architectures. Why cascaded models give you control and fused models trade complexity for naturalness. What we're learning from shipping production agents at scale.

Firecracker microVMs, gVisor containers, persistent workspaces, and the $24M Series A nobody quite expected. The sandbox layer beneath every serious agent — and how to pick the right one.

Why your cascaded voice agent sounds robotic — and how to fix it with concrete examples, SSML pause patterns, emotion tags, and personality-as-behavior prompting techniques.

Caching, routing, distillation, and per-task model selection. The four moves that take a $0.40/task agent to $0.04/task without anyone noticing the difference.

Operator died, Browser Use became the default substrate, Manus shipped at scale, and the gap between demo and reliable production narrowed considerably. A field report.

The three-role pattern that powered Manus, then LangChain Deep Agents, then half the production agents shipping in early 2026. Why it works, when it doesn't, and how to actually build one.

A deep dive into context engineering — the techniques that separate toy demos from production AI agents. Covers compaction, offloading, isolation, caching, and prioritization with real examples from Manus, Claude Code, and Devin.

How exploring LLM fine-tuning led to building a Gymnasium-compatible RL environment where 7 LLM-powered agents run a company — trained with GRPO + LoRA on Qwen 2.5 14B — and what we learned about reward design, emergent collaboration, and the future of agentic AI.

AI agents are drowning in tools. The more APIs you connect via MCP, the worse your agent performs. Here's why, and what Code Mode changes.

We've been so obsessed with what AI can do that we forgot about how it feels to use it. The AI experience layer is the next frontier — not the model, not the capabilities.

Past ~30 tools, agent reliability falls off a cliff. Past ~100, it's chaos. Here's the actual engineering — RAG-over-tools, semantic routing, dynamic loading, and namespacing — that production teams ship to stay sane.

The orchestrator-worker pattern that took over agent design in late 2025 is the same pattern that took over backend design in 2014. The wins are real. So are the failure modes.

A comprehensive hands-on comparison of seven open-source AI agent frameworks — which one should you actually use?

Six serious frameworks, four orchestration styles, and one tired question I keep getting asked. Here's the decision tree I actually use.

Fourteen months in, the Model Context Protocol stopped being a curiosity and started being plumbing. Here's what changed over the holidays — registries, governance, and the first scaling pains.

Open-sourcing my childhood dream — an AI agent that understands context, makes decisions, and controls connected devices just like JARVIS.