tinyhumansai/openhuman uses a local-first Memory Tree to compress your digital life and orchestrate multiple agents, already at 37k stars in early beta; Vercel Labs' fx is a native coding agent CLI written in Zig at under 8 MiB; NVIDIA open-sources labs-OO-Agents, packing an agent's prompt/tool/workflow into a single Python class; CopilotKit/OpenBot containerizes agents with governance gates — every action is reviewed before execution. Agno v3.0.0 is a major breaking release requiring database migration, and Haystack v3.1.0 adds multi-agent delegation via AgentTool and context compression via CompactionHook.
Panniantong/Agent-Reach wraps yt-dlp, twitter-cli and friends behind a single CLI so agents can read Twitter/Reddit/YouTube/Bilibili; LangChain ships deepagents, a batteries-included harness with filesystem access, sub-agents, and skills; Tracer-Cloud/opensre frames AI SRE agents as a scored RCA benchmark; Anthropic's claude-plugins-community marketplace adds a review pipeline for community plugin trust, gaining +490 stars in a single day. GitHub Copilot CLI v1.0.81-8 (pre-release) adds Grok 4.6 xhigh reasoning and live plugin hot-reload.
HKUDS/nanobot rode its v0.3.0 'The Agency Release' to 47K stars in 7 months as a self-hostable personal agent runtime; genspark-ai/genoffice hit 3,400 stars in 3 weeks with an open-source AI office suite for native file formats; NVIDIA published labs-OO-Agents (NOOA), collapsing agent state into a single Python class; repo-context-mcp is an MCP server that helps coding agents understand repos without stuffing the entire codebase into the prompt. Framework-wise, Mastra 1.60.0 adds durable execution and Cloudflare Sandbox; pydantic-ai v2.33.0 has a breaking change from the anthropic SDK's switch to httpx2.
Cursor open-sources its official plugin marketplace cursor/plugins, standardizing the ecosystem with plugin.json + skills + MCP definitions (+470 stars in one day); apache/maka enters the Apache incubator with an append-only event log recording every tool call and permission decision for auditable local-first agent workbenches; magnitudedev/magnitude auto-detects hardware, downloads, and runs models locally out of the box for offline agents; vercel/eve puts agent capabilities into convention directories like tools/, skills/, and schedules/ — the filesystem is the interface. On the framework side, pydantic-ai ships a v2.32.1 patch.
Vercel ships eve, a filesystem-first TypeScript agent framework tightly coupled with its AI Gateway/Sandboxes; Prime Intellect's Prime Agent treats the entire conversation context as program variables with a self-modifying Continual Harness; aden-hive's Hive replaces pre-compiled execution graphs with 'clone the Queen'; HKUDS's nanobot hits 47k stars in six months with its v0.3.0 Agency Release. No major version bumps on the watchlist today.
Three papers tackling multi-agent platform challenges from three angles: organizational design, security isolation, and user-level authorization. IMACS decomposes multi-agent systems into three independently swappable layers (organization, coordination, collaboration algorithm), letting framework designers mix and match agent roles and strategies like building blocks. APPA uses context branching to break the usability bottleneck of IFC (Information Flow Control), cutting prompt injection exfiltration rates from 31–50% down to 0–7% across 4 models. A UW survey of 21 agent authorization proposals finds that nearly all systems offer only developer-defined global policies — user-level personalized authorization is virtually absent. Together, the three papers outline the gaps agent platforms must close on the road from prototype to production.
Three papers probe the real-world limits of AI Agents from different angles: ORCA-bench drops LLM Agents into production SRE on-call for root cause analysis — the best model scores only 40%; AgentS4D reveals the safety blind spot of workspace agents — 66% of 'successful' runs still triggered dangerous behavior; a Context Files study finds that AGENTS.md / CLAUDE.md files show no measurable improvement in coding agent correctness across 288 controlled trials.
Three papers today converge on one core question: **are AI Agents production-ready?** The answer is unanimously — far from it. HANDBOOK.md reveals that even the strongest frontier models achieve only **36.2%** SOP compliance when dropped into a simulated enterprise; a LangGraph paper delivers three actionable stateful workflow recipes plus a decision guide on when *not* to use LangGraph; and MM-ToolSandBox is the first benchmark to quantify how hard visually-grounded tool calling really is — the best of 12 models still falls below 50% success. Three dimensions — compliance evaluation, framework design, visual tool use — together map out exactly how far Agents are from real-world deployment.
Three papers tackling core Agent challenges: TRACE-ROUTER shows per-call model routing breaks in multi-step agent flows and proposes task-level routing with RL; OmniaBench builds a 1,431-question benchmark spanning consumer, enterprise, and engineering scenarios where top models (Claude Sonnet-5) still score under 60%; a self-calibrating agent framework uses ARIMA time-series forecasting to detect and correct prediction drift without human supervision.
Three papers today converge on infrastructure reliability for production multi-agent systems: the first compares how MCP and A2A divide responsibilities (complementary, not competing); the second benchmarks capability degradation across 12 top models after tool version updates, finding 13-14% drops even in frontier models; the third reveals that chaining safe models into a pipeline does not yield a safe system — defenses actually rely on cloud-provider server-side filters. Together they answer three questions every platform engineer faces: how to connect tools, whether tool upgrades break things, and whether chained agents stay secure.
Three papers today strike at the capability boundaries of AI coding agents from three angles: **ICAE-Bench** tackles interactive development under ambiguous requirements, exposing how current benchmarks lag behind the vibe-coding era; **EvoAgentBench** reveals the pitfalls of agent self-evolution ability transfer, where a mainstream method causes a −12.3 point negative transfer; **PERFOPT-Bench** opens the new track of performance optimization as an agentic task and finds that framework choice often matters more than model choice. The takeaway: production agent evaluation is far harder than existing tools suggest, and the field urgently needs benchmarks closer to real-world scenarios.
Three papers approaching 'how to make agents reliably solve complex tasks' from complementary angles. NVIDIA proposes writing agents as plain Python classes so development, testing, and tracing work like normal software engineering. BAAI's AREX demonstrates a deep-research agent that recursively verifies and refines its own conclusions, outperforming comparable-scale models on BrowseComp, HLE, and other benchmarks. The third paper surveys 1,250 papers to build a clear taxonomy for the chaotic term 'AI self-improvement,' helping you tell which techniques are production-ready and which remain research-only.
Three papers from ecosystem, failure, and memory angles: which open-source Agent frameworks are worth a long-term bet (beyond star counts), the six failure categories where Agents repeatedly stumble, and how to give Agents long-term memory that reasons across multiple entities. Together they form a 'framework selection guide + failure prevention checklist + memory system upgrade roadmap' for Agent platform developers.
Three papers tackle the same core question from infrastructure, observability, and evaluation angles: how do you build truly reliable agent systems? Dyserve uses mathematical optimization to decide which LLM each agent workflow node should use within 60ms, beating all baselines on both accuracy and latency. AgentLocate solves the ops nightmare of not knowing which agent broke a multi-agent pipeline, automatically pinpointing the responsible agent and the failure timestep (COLM 2026 accepted). PolyWorkBench delivers a warning: state-of-the-art LLM agents degrade significantly in multilingual workflows — global product scenarios still have a long way to go.
Three papers, one question: what makes an agent system actually work? SearchOS-V1 offers an architectural answer — externalize search progress as structured state and record failed paths so multi-agent collaborative search becomes reliable. AutoSynthesis shows that highly structured academic tasks (systematic meta-analysis) can be fully automated by a multi-agent pipeline. Digital Pantheon addresses the persona engineering problem of keeping agents in character under pressure, introducing an auditable multi-agent negotiation architecture. Together they map the latest solutions to three core agent challenges: runtime design, workflow orchestration, and persona engineering.
Three papers tackling three core agent-platform challenges: MyAG introduces a graph-theoretic decomposition of agent systems into component / workflow / search layers; a self-improvement survey unifies the entire 'how agents evolve from experience' landscape under one formula; and MemPoison reveals persistent memory as the most vulnerable attack surface, with a 1,227-case benchmark. Together they cover: how to architect → how to evolve → how not to get compromised.
Three papers tackling core agent platform pain points from different angles: the first proposes a framework for making e-commerce sites AI browser-agent friendly, boosting success rates from 49% to 89%; the second uses dynamic abstention-aware RL to teach search agents when to say 'I don't know'; the third introduces an agent OS for embodied robots whose multi-modal graph memory and context-isolated skill execution offer direct inspiration for general agent platforms. Together they cover the full chain from front-end UI design to inference reliability training to execution-layer memory architecture.
Three papers converge on the same question: how should each execution unit of an agent be designed so it's auditable, reusable, and recoverable at minimal blast radius when things go wrong? ATG decomposes tasks into DAGs for parallel subtask execution and intermediate result reuse; PalmClaw wraps native mobile APIs as structured tools, ditching brittle GUI click sequences; IoAT extends agent networks into the physical IoT world — from smart buildings to edge devices — sketching a coordination blueprint across cloud, edge, and sensor layers. Common thread: execution boundaries must be crisp, actions must be auditable, and failures must be locally recoverable.
Three papers today revolve around two themes: **security** and **evaluation**. Prismata blocks cross-site prompt injection at the page level; aiAuthZ establishes a cryptographic identity-bound authorization gateway at the tool-call level — together they argue the LLM itself should never be the security boundary, and platforms must enforce defenses at the architecture layer. The third paper, UniClawBench, moves agent evaluation from sandboxes into the real world, diagnosing failures by 'capability dimension' instead of 'task scenario' — giving platform engineers a sharper tool for model selection and failure analysis.
Three papers today converge on one question: how can Agent systems operate reliably? STRACE tackles noisy optimization inputs — precisely identifying root causes from massive noisy failure traces so automatic optimization stops getting derailed by redundant cases. The Blind Curator exposes an unsettling silent failure mode — the skill retirement mechanism in self-evolving Agents completely breaks down beyond a certain LLM judge bias threshold, and no amount of additional data can fix it. Severity Scale transforms 'how bad was this Agent attack' from binary success/failure into a seven-level action-harm score, finally giving security evaluation the granularity it needs. Read together: optimization quality, self-evolution soundness, security evaluation precision — three different layers, all pointing toward Agent trustworthiness.
Three papers today map the 'evolutionary frontier' of Agent platforms: EvoSOP lets agents extract reusable SOPs from past execution traces instead of replanning from scratch; AgenticSTS proposes a strict bounded-memory contract with five typed layers replacing endless context stacking; Spider 2.0-AIFunc reveals that AI functions are already embedded in cloud SQL syntax, yet the best model hits only ~67% accuracy — a new challenge every data agent must face. Together they outline three critical gaps agent platforms must close in 2026: tool efficiency, memory architecture, and data capabilities.
Three papers sound the Agent security alarm from different angles: FARMA silently corrupts Agent reasoning memory with 100% success rate bypassing all defenses; Vera tests 4 production Agent frameworks (including Claude Code) with 93.9% average attack success rate; PiSAs reveals cross-user information leakage in shared Agent environments as a severely underexplored problem. Together, they represent the security reality that those deploying Agent platforms must confront.
Three papers today converge on a single core issue: the massive gap between how AI Agent systems perform in idealized labs versus real-world deployments. AgentGym2 (ACL 2026) quantifies evaluation distortion with a new benchmark; an Agentic RL paper proposes engineering infrastructure for agents that self-evolve in production; and ComfyClaw demonstrates end-to-end skill self-evolution in image generation workflows. Read together, they form a complete map from evaluation → deployment → runtime evolution.
All three papers today center on making agent systems safer, more predictable, and less failure-prone. The first two come from the same research group and take a static-analysis angle: one systematically uncovers why and how often agents get stuck in infinite loops, while the other builds dependency graphs for entire agent codebases to enable security audits and component inventories. The third targets multi-agent software development, introducing LLM confidence scores into the collaboration flow to prevent early hallucinations from cascading downstream.
Three papers today attack the same core question from different angles: **how to make agent workflows truly reliable in production**. Mnemosyne brings the database Transaction concept into agent workflows, requiring every LLM output to pass admission control before taking effect. PaperPilot shows how to train a 9B model to plan multi-turn search workflows as DAGs and dynamically revise them based on user feedback. SEA lets agents self-improve on the fly while issuing auditable safety certificates. Together, the three papers nearly cover the full reliability stack for agent systems: execution-layer protection, training-layer workflow learning, and update-layer safe evolution.
Three papers tackling core agent platform pain points: ReContext offers a training-free inference-time fix so LLMs stop overlooking key evidence in 128K contexts; the second reveals systematic public-private divergence (3% → 40%) when agents debate across social hierarchies; the third raises alarms about three widely-cited coding agent benchmarks — only 8% of SWE-Perf tasks reproduce reliably.
Three papers each expose an evaluation blind spot in agent systems: memory makes agents more sycophantic yet rarely gets tested (MemSyco-Bench); existing safety benchmarks flatten every failure into pass/fail, obscuring root causes (Adversarial Pragmatics); LLM agent collectives, communicating in natural language, are actually more interpretable than black-box neural networks (Conversable Complexity). The combined message: the way we evaluate agent systems needs a comprehensive upgrade.
Three papers today reveal a core tension: current agent systems shine in closed environments but degrade sharply once conditions shift even slightly. An ICML 2026 paper systematically quantifies this problem through the lens of tool use; the second shows how a pipeline of 6 specialized agents can tackle complex cross-domain tasks; and the third reminds us from a UX perspective that agent 'personality intensity' isn't a case of more-is-better — moderate is the sweet spot.
Three papers spanning distinct dimensions of the AI Agent ecosystem: Qwen introduces the first Language World Model covering seven agent domains, enabling agents to train in simulated environments instead of relying on real APIs; Kuaishou's AgentX demonstrates industrial-scale multi-agent deployment, boosting recommendation algorithm iteration efficiency to 13.8x human output; OpenAI uses real Codex usage data to quantify how agentic AI is reshaping work across job functions, revealing that non-technical roles (legal, research) see even greater agentic dividends than engineers.
Three papers converge on one core question: **how do we actually evaluate whether an agent is good enough?** SWE-Explore isolates the most overlooked middle step of coding agents — understanding the codebase — and benchmarks it independently; Claw-SWE-Bench reveals that harness design (the adapter) is the real lever behind coding agent score jumps, with the same model leaping from 19% to 73% by swapping adapters; Red Queen Gödel Machine (Cambridge × NVIDIA) goes further by co-evolving the evaluator alongside the agent, breaking the ceiling of static benchmarks. Read together: **evaluation infrastructure is becoming the most critical competitive moat for agent platforms**.
Three papers dissect the challenges of making agents production-grade infrastructure: Agent libOS addresses what an agent runtime should look like underneath; Autodata (Meta FAIR) shows how agents can manufacture and continuously improve their own training data; GAIE proposes tiered oversight for coding agents under regulatory constraints. Together, they sketch a complete blueprint showing that agent platforms need redesign across architecture, data, and governance.
Three papers tackling production-grade agent systems from different angles: a full-stack practical guide from LLM foundations to multi-agent architectures, a lightweight scaffold that lets agents decide when to compress their own context, and an RL training algorithm that refines credit assignment from tool-call boundaries down to the token level. Together they map out three key questions for building an agent platform: what architecture to learn, how to keep it stable at runtime, and how to train it better.
Three papers, three angles: **RigorBench** evaluates coding agents on process discipline rather than just pass rates, introducing five dimensions of engineering rigor; a production-focused paper shows how to customize and accelerate large multi-agent systems for enterprise use (4.48x throughput gain); and a governance paper proposes a formal protocol language for specifying human-agent boundaries in the SDLC — turning 'which decisions AI can make' from a line in a prompt into a machine-verifiable spec. Together they cover evaluation, deployment, and governance.
Three papers paint a full picture of how agents land in the real world: Perplexity + Harvard Business School use production data to quantify the agent vs. chatbot gap for the first time — 87% faster task completion, and agents attract cognitively harder work; Self-Harness shows how agent scaffolding can automatically mine weaknesses and fix itself, yielding 33-60% relative gains across three models; The Consistency Illusion exposes a core trap in multi-agent debate — output-level consensus can mask fundamentally misaligned reasoning underneath. Read together, the signal is clear: an agent's real competitive edge isn't a stronger model — it's production-data-driven scaffolding self-improvement and rigorous validation of collective decision reliability.
Three papers tackle 'making agents more reliable' from different angles: EinsteinArena builds a persistent platform for multi-agent collective intelligence that found 12 new best-known solutions in math; APEX extends agent self-evolution beyond prompt tuning to simultaneously evolve principles and workflow topology; AI Economist Agent demonstrates how to ground every quantitative claim in formal model execution via knowledge graphs. The signal across all three: the next competitive dimension for agent systems is the infrastructure for collective knowledge sharing and how to make self-evolution and precise quantitative output work in production environments with real data.
Three papers challenging conventional wisdom in the agent space: ACCORD shows agents act on assumptions instead of observations and fixes it with active grounding (AppWorld 42% → 62.6%); 'The Illusion of Multi-Agent Advantage' proves auto-generated MAS underperforms single-agent CoT-SC at 10x the cost; 'Agentic Very Much' provides large-scale GitHub evidence that coding agent adoption in new projects has more than doubled year-over-year. Together they signal: agent tools are spreading fast, but the assumptions that 'multi-agent is always better' and 'agents understand your instructions' are being challenged by data.
Three papers targeting three critical infrastructure layers of Agent platforms: HarnessX introduces a 'harness as evolvable component' framework that turns static Agent scaffolding into a self-optimizing system (+14.5% average across 5 benchmarks); the second studies skill-conditional trust routing in multi-agent collaboration, revealing when fine-grained trust actually helps and how attackers can hijack it; OCELOT tackles security with a 'posterior leakage budget' mechanism to prevent Agents from gradually leaking user privacy to external services. Together they cover framework design, multi-agent governance, and privacy security — exactly the three pitfalls most commonly hit when shipping Agent platforms to production.
Three papers address agent reliability from three layers. RefGRPO fixes a neglected reflection calibration problem in agentic RL, turning agents into their own verifiers. 'Agents All the Way Down' delivers a complete custom-agent methodology from LLM substrate to production, arguing that solid foundations matter more than framework choice. EurekAgent uses autonomous scientific research to show that environment engineering beats process engineering for agent reliability.
Three papers paint the 'agent reality of 2026': UC Berkeley's real-workplace benchmark shows top agents pass only 2.6% of the hardest tasks; Microsoft finds developers spontaneously develop 4 oversight behaviors that tools don't support; Reins AI argues task-level monitoring can't see the worst structural failures in early-stage agent systems.
Three papers tackling core Agent platform challenges from the angles of memory architecture, training efficiency, and reliability evaluation. HORMA proposes a hierarchical filesystem memory architecture so Agents stop collapsing under exploding context in long workflows; TRACE redesigns rollout budget allocation for Agent RL training, squeezing an extra 2.8 percentage points on Multi-Hop QA from the same compute; and τ-Rec exposes the 'reliability cliff' in multi-turn conversational recommendation Agents — even the strongest model drops to just 38% reliability over four consecutive runs, a sobering number for any team planning to ship an Agent product.
Three papers today explore 'agent-native infrastructure' at different layers: the first redesigns API error responses to give agents structured recovery hints, dramatically improving tool-call success rates; the second argues Agent OS is the right abstraction for long-running agents; the third builds a hardware-aware simulator for multi-turn agent serving to quantify KV cache scheduling trade-offs. From APIs to OS to hardware, every layer of the agent stack needs rethinking.
Three papers today converge on one theme — moving agents from experiments to reliable production: a multi-agent troubleshooting architecture deployed at hyperscale cloud with 90%+ autonomous resolution; a memory mechanism that lets agents learn from past tool-call successes and failures without retraining; and the first systematic comparison of six AI-assisted development process frameworks across six dimensions.
Today's three papers center on **security boundaries and capability optimization for coding agents**: SABER introduces the first executable-workspace benchmark and finds even the best models have 54%+ dangerous operation rates; the second paper has 100+ real developers collaborate with a secretly sabotaging AI agent for five hours — 94% never noticed; SePO shows that auto-optimizing system prompts alone (no model changes) yields an average 4.49-point gain across five benchmarks. Together they remind platform builders: agent safety is harder to measure and harder to catch than assumed, yet low-cost improvement paths exist.
Three papers mapping to three layers of the agent platform stack: AgentJet (training layer) introduces a distributed framework for simultaneous RL training of multiple heterogeneous LLMs, solving the fundamental limitation of single-model-only training tools; AdaPlanBench (evaluation layer) reveals with a 67.75% ceiling that LLM agents are far from ready for real-world scenarios where rules are disclosed progressively — it is the first benchmark to systematically quantify this adaptive planning capability; Beyond Tokens (communication layer) surveys multi-agent systems that replace text with embeddings for inter-agent communication, providing a taxonomy to evaluate the engineering trade-offs of this new communication path.
Three papers tackle agent infrastructure decisions: ADK Arena quantitatively compares LangGraph, AutoGen, CrewAI and other frameworks on real-task completion rates and costs; Agent Memory offers the first computer-systems taxonomy of 10 memory designs covering latency, bandwidth, and scalability trade-offs; Search-Time Contamination questions deep research agent benchmarks—agents can search for answers during evaluation, inflating scores by up to 4%. Together they provide new quantitative tools for three core platform decisions: framework selection, memory architecture, and evaluation trustworthiness.
Three papers on three deep agent-system questions: **memory architecture** (which design generalizes?), **self-evolution** (can AI build agents autonomously?), and **security blind spots** (how domain-dependent is CUA safety?). AutoMEM shows agents that actively manage their own memory generalize better than those relying on external pipelines; Meta-Agent Challenge reveals that frontier models still fall well short of autonomous agent development; Domain-Conditioned Safety finds Claude Sonnet 4.6 has 0% prompt-injection ASR on web tasks but 100% on code tasks — all three challenge core design assumptions in agent platforms.
Three papers tackling core agent platform gaps from three angles: APB introduces a 4,209-question diagnostic benchmark that separates planning failures from execution failures; MetaForge lets agents forge missing tools at runtime, breaking the static-toolbox ceiling; RUBAS decomposes agent safety into four scoring dimensions and uses RL to balance helpfulness against safety. Together they address whether your agent system can be diagnosed, can self-extend, and can go to production safely — three checkpoints researchers tackled head-on today.
Three papers tackling 'how to build more reliable, evolvable Agent systems' from different angles: the first reveals real LLM call costs in multi-model Agent systems through execution traces, giving platform engineers hard numbers; the second proposes treating the entire memory pipeline as self-evolving code to fix memory-architecture drift in long-running tasks; the third exposes evaluation blind spots in Agent continual learning benchmarks—current benchmarks can't tell whether agents actually learned anything—and introduces a more rigorous controlled stream framework.
Three papers tackle agent memory from three angles: interoperability standardization, latent-space efficiency, and budget-awareness gaps. The first proposes a cross-framework memory wire format to unify mem0, Letta, and Cognee; the second replaces text-in-context experience retrieval with latent-space vector search (best on 12/13 benchmarks); the third is a large-scale evaluation revealing all five frontier models are systematically over-optimistic and unable to sense mid-task budget shortfalls — task strength ≠ budget awareness (r=0.35). Read together: memory standardization challenges → a new efficient memory architecture → a systemic blind spot in deployment costs.
Three papers tackling core agent platform pain points from different angles: the first proposes compiling LangGraph-style orchestrator logic directly into small model weights, cutting per-conversation cost by 128–462×; the second, from IBM Research, builds a three-level automated evaluation framework that solves the 'agent broke but which step failed?' problem; the third, from Microsoft, proposes a portable memory protocol enabling memory handoff between Claude / GPT-4 / Gemini without losing state. Together they cover three critical dimensions: deployment efficiency → behavior evaluation → memory portability.
Three papers at three different layers: BenchTrace ran 1,821 agent failure episodes and found GPT-4.1 and Qwen3-32B pass less than 30% on diagnosing their own failures — reflection is far weaker than assumed; Beyond Autonomy distills a three-tier governance architecture from enterprise SaaS production, filling the missing 'governance' piece in current agent frameworks; Insuring Every Action prices every agent action using actuarial concepts and introduces reserve capital budgets, creating an entirely new runtime risk vocabulary. The common thread: the core challenge of enterprise agent deployment has shifted from 'can it do the job' to 'what happens when it fails, who reviews it, and how do you quantify the damage.'
Three papers tackle AI Agent practice from three angles: a design language, a security map, and cognitive limitations. The first builds a two-axis classification framework giving engineers and researchers a shared vocabulary for agent architecture trade-offs; the second systematically catalogs safety and privacy risks across tool calls, memory, and multi-step execution in agentic AI; the third is the most impactful — a large-scale experiment with nearly 40,000 AI-generated ideas reveals that AI research agents tend to circle existing literature rather than genuinely broadening scientific exploration.
Three papers tackle 'how to make agentic AI work better' from three angles: the first (UIUC × Intel) profiles real agent workloads and finds the bottleneck is KV-cache management, not long prompts; the second (PwC) runs controlled experiments challenging the RAG-first default, showing grep often beats vector search in agent loops; the third (Microsoft Research) open-sources a complete agent training framework that lets the community train same-tier SOTA agents without relying on closed-source APIs.
Three papers today point to three gates agents must pass on the road from demo to production: AgentTrust adds a runtime interception layer before tool calls, filling the gap between static blocklists and post-hoc benchmarks; Hermes scans 600 production endpoints and finds existing REST API docs almost universally unfit for MCP agents (4 issues per endpoint on average); PARPO pushes personalization from the prompt layer down into RL training so agents behave differently per user instead of being 'okay for everyone.' Together they outline how much hard work remains on the security gate, API readiness, and personalization fronts for production-grade agent systems.
Three papers tackling agent infrastructure from different angles: Microsoft proposes a brain-inspired six-mechanism memory architecture that compresses memory stores by 58% while retaining 97.2% precision on real codebase data; Megagon Labs challenges the step-by-step reasoning default, showing that full-horizon planning saves 2–4.7x tokens on data-centric tasks; and a neuroscience-informed framework turns multi-agent topology selection (Chain / Star / Mesh) from guesswork into computable diagnostics.
Three papers on the most pressing question for agent platforms in 2026: can safety constraints in multi-agent systems actually hold up during execution? 2605.10481 names a new failure mode — 'constraint drift': safety rules written at design time silently weaken as they pass through agent delegation, memory read/write, and tool calls, arriving at the output already distorted. 2605.07728 (SARC) proposes an architectural fix: compile regulations into four enforceable checkpoints embedded in the agent execution loop — no more relying on prompt reminders — and is open-sourced. 2605.13851 uses psychology experiments to show that when a multi-agent system's coordinator is invisible, the system's protective behaviors drop significantly — a direct design warning for mainstream orchestrator-based architectures.