calesthio/OpenMontage turns a general-purpose coding agent into a full video-production studio with 12 pipelines and 700+ skill files, jumping to 50k stars this week; Anthropic's own official plugin marketplace claude-plugins-official gained +292 stars in a single day; rohitg00/agentmemory gives coding agents cross-session memory via BM25 + vector + knowledge graph retrieval, claiming 95.2% R@5 on its own LongMemEval-S benchmark; sodiumsun/agenttrail builds a local, real-time task map for Claude Code, Codex, and Cursor. No major framework releases today.
thedotmack/claude-mem lets context survive across sessions via compressed memory, crossing 90K stars; volcengine/OpenViking unifies memory, RAG, and skills into a virtual filesystem browsable over the viking:// protocol, up 3,078 stars this week; apache/maka enters the Apache Incubator, turning an agent's execution history into a replayable event-sourcing log; K-Dense-AI/scientific-agent-skills lets 175,000 scientists turn a general coding agent into a domain expert with 163 skills. Haystack v3.1.0 adds AgentTool for multi-agent delegation.
Twin1 AI closed a $20M seed round co-led by Bessemer Venture Partners, Tribeca Venture Partners, and Aramco Ventures, with valuation undisclosed. The bet: the atomic unit of enterprise knowledge isn't the document — it's the person. While every Agent startup races to plug into document repositories, Twin1 goes after the context that lives in people's heads and was never written down.
D2ACCI introduces a dual-loop diagnostic protocol that localizes memory failures to specific pipeline stages, raising diagnostic success from 0% to 98–100%; Salesforce re-evaluates memory-based self-improving agents and finds that shuffling task order turns an expected +1.5% gain into a -4.5% drop; GraphWake shows that poisoning just 10% of agents' memories can drastically amplify group opinion polarization
Volcengine (ByteDance) open-sources OpenViking, replacing black-box vector search with a viking:// virtual filesystem for agent memory — benchmarks show 80%+ accuracy while saving 34-91% tokens. munder-difflin wraps multiple coding CLIs into a desktop office with shared memory; ai-memory solves cross-CLI amnesia with a Rust MCP server; mukul975's cybersecurity skill pack rockets to ~28K stars in a day. pydantic-ai v2.32.0 adds OpenRouter/xAI attachment search and instrumentation improvements.
QUMem uses episode segmentation plus a three-stage agent pipeline to infer user state, beating the strongest baseline by 4.6 pp overall success rate on KnowU-Bench; LENS retrieves without pre-built indexes, achieving 84.8% evidence recall vs ReAct's 50.4% with zero degradation when indexes go stale; Intent-Guided Decoding arbitrates between retrieved content and model memory at decode time, yielding up to 65.4 pp accuracy gains on factual-conflict benchmarks
RippleMem boosts LongMemEval-S accuracy by up to 11.87% via associative memory spreading while cutting graph construction cost to 1/30; Total Recall at What Cost? measures 18–69% prediction error in memory system serving costs with no system winning both cost and accuracy; MESA's dynamic structure selection achieves 8.5% higher accuracy on AMA-Bench while saving 41% of evidence tokens
SkillEvo replaces single-turn QA evaluation with multi-turn interaction feedback so skill evolution doesn't stall after the first round, outperforming self-reflection by 23 points; SkillShapley brings Shapley values to skill step attribution — 99 evaluations approximate the exact ranking, revealing that 'decision-bridging steps' are the high-value ones; MindMemOS unifies memory management with an entity-property-time structure, hitting 94% on LOCOMO and lifting SpreadsheetBench success rate by 9.2 percentage points through skill evolution
EvoGraph-Mem uses a failure-aware editable graph to let agent memory self-correct, preventing stale insights from poisoning decisions; MAP-Graph turns provenance tracking from post-hoc audit into real-time access control, achieving 95% success across 2,700 synthetic tasks; MaSRead shows multi-agent KV cache sharing is possible but requires content-addressed reading instead of positional addressing
Tool interface design boosts coding agent consistency by 4.7x while halving token usage; memory distillation lifts a 4B model's AppWorld accuracy by 27.2 percentage points to near-frontier level; institutional design experiments show that identical safety rules paired with different enforcement mechanisms yield violation rates ranging from 0% to 23%
Muscle Memory proposes 'compiled memory' over retrieval-based memory, winning 88.9% of personalization matchups across 90 scenarios; MoRSE uses role-subtask conditioned LoRA experts to significantly outperform prompt-only role differentiation in code generation; ASCon builds a unified failure attribution model, improving by 5.83%, 10.63%, and 14.73% across three attribution targets
Memory Reward Inflation finds that self-improving agents' memory rewards self-inflate — wrong experiences grow more confident over time; LUCID boosts accuracy from 54.0% to 56.9% on BIRD. RoMeRL compresses memory state space with fixed-dimension semantic coordinates, cutting Cold-Q ratio by 80% and LLM calls by 21.1%. ToolLIFT abstracts tool trajectories into function-level workflow graphs, consistently outperforming existing methods on three OOD benchmarks
VerMem's seven atomic memory operations plus dual verifiers lead all baselines by 5-8 points across five benchmarks; SafeCommit cuts unsafe action rate from 41.2% to 2.6% while maintaining 97.4% task completion; ToolLIFT abstracts tool trajectories into function-level workflow graphs, outperforming the strongest baseline by 3-5 points on OOD benchmarks
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, 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 converge on one trend: the bottleneck for production agents is no longer model capability — it's state management. Paper 1 (Amazon) shows that pre-compiling repetitive steps into tools cuts p50 latency by 42% and error rate by 53%. Paper 2 introduces a standalone memory agent that proactively pushes critical state to the action agent, addressing behavioral state decay in long-horizon tasks. Paper 3 uses recursive multi-agent orchestration to overcome a single agent's inability to search both broadly and deeply. Together: **tool compilation, proactive memory, recursive orchestration** are the three pillars of agent platform engineering in 2026.
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 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.
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 tackling three core Agent platform challenges: **upgrading memory from retrieval to reasoning state** (User as Code), **removing the central orchestrator while cutting costs** (DeLM), and **letting users quickly verify Web Agent results** (HANSEL). Together, they form a near-complete technical map for a high-trust Agent platform — memory layer, coordination layer, and explainability layer, each addressed by one paper.
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 tackling core Agent platform pain points: one decomposes Agent memory into four measurable system modules, revealing that current evaluations only checking 'did it get the answer right' are far from enough; one borrows the software engineering concept of 'design review' to enable automated verification of Agentic Workflows before deployment; and one uses 14 large-scale parallel experiments to prove that the benchmark leaderboard you trust reshuffles its rankings when the context changes — and proposes a more reliable alternative metric.
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 core assumptions about agent tool use and memory: Evoflux shows compact models nearly fail at MCP tool catalogs (3% success) and uses inference-time evolutionary search to reach 17-24%; FlowBank precomputes diverse workflow portfolios and routes at inference time, beating handcrafted designs by ~15%; GitOfThoughts reveals memory only helps when problems are near-duplicates (similarity > 0.8), but git version control offers an engineering path through auditability and replayability.
Three papers tackle the same core question from different angles: **how to evaluate and operate AI Agents under real deployment conditions.** Emergence World builds a multi-agent sandbox that runs continuously for weeks, exposing behavioral drift and cross-model contamination invisible to short-term benchmarks; a survey paper establishes a complete taxonomy for agent environment design (8 attributes x 8 domains) and proposes symbolic vs. neural synthesis paradigms; Martin Monperrus's position paper declares outright that coding agents have crossed the threshold and human code review can retire.
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 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 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 today zero in on the cost-capability frontier of agent deployment at scale: SR²AM redesigns planning architecture so a 30B model uses 90% fewer tokens while competing with 685B-1T systems; GroupMemBench reveals that existing memory systems completely fall apart in multi-party group conversations (the best system hits only 46% accuracy, and 1990s BM25 keyword search actually beats it); AgentFloor confirms with 16,542 test runs that the bulk of short-range tool use in agent pipelines simply doesn't need a large model. The common thread: under compute cost pressure, precisely determining 'how much intelligence each component needs' has become the central design challenge for agent platforms.
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.