Research Forward

One Paper. One Page. One Research Direction.
We show where it can go next.

[DAIR.AI @dair_ai]

Great paper from Google and colleagues.

It proposes an interesting approach to improve agents on long-horizon tasks.

Long-running agents slow down and start poisoning their own context.

Both symptoms come from the same design choice, which is keeping execution alive by appending every observation, action, and reasoning trace to a growing conversation.

SKILL.state replaces that history with an explicit mutable execution state.

At each step the model sees only the immutable skill specification, the current structured state, and the latest observation.

Intermediate reasoning gets discarded the moment it produces a validated state update, so the prompt stops growing with the run.

Across several datasets, models, and execution environments, task accuracy improves while cumulative token consumption drops.

The abstraction is architecture-agnostic, so it ports into existing skill runtimes.

Paper: https://t.co/zsdo8ndR0I

Chat with Paper: https://t.co/sS7lLntuAd

[marfin @marfinxx]

This Microsoft research paper is f*cking brilliant

Microsoft researchers just analyzed 115 multi-agent trajectories and proved that 68% of agent crashes stem from invisible cascading failures that occurred 10+ turns earlier

Their new framework, AgentRx, replaces manual log inspection with programmatic contract synthesis to isolate the exact turn where an agent went off the rails

Why multi-agent debugging fails in production:
→ The Multi-Failure Cascade: agents average 6.7 compounding errors per failed run, where an early schema misunderstanding silently infects downstream subagents
→ The Status Code Blindspot: 71% of fatal root-cause steps return "OK" because language models generate valid JSON containing false semantic premises
→ The Localization Gap: developers waste hours debugging the final crash point instead of the earliest unrecoverable pivot turn

Microsoft's 3-stage causal attribution pipeline:
[1] Trajectory Normalization → standardizes multi-agent message DAGs and tool payloads into unified state representations
[2] Invariant Synthesis → generates domain-specific programmatic constraints from tool schemas and operational policies
[3] Step-Indexed Validation → checks every action against the constraint ledger to pinpoint the critical failure turn

Hypothesis Verification & Practical Validation:
Microsoft hypothesized that generating step-indexed constraint validation logs directly from execution traces allows automated diagnostics to isolate critical failure steps with high precision. Practical validation confirmed the findings: integrating Microsoft's AgentRx validation framework into our trace engineering harness across 150 multi-agent workflows boosted root-cause step localization from 31.5% to 58.7% (+27.2% gain) while slashing average debugging error distance from 5.7 to 2.4 steps and cutting MTTR by 64%

You cannot fix multi-agent systems by reading terminal text at the crash site. Reliability requires step-level constraint ledgers, causal back-tracing, and programmatic invariant verification

Read the complete breakdown in the article below ↓

[beamnxw ./ @beamnxw]

This paper is f*cking brilliant

A computer science paper formalizes temporal knowledge graph memory engineering for autonomous AI systems

The result: Zep's Graphiti engine achieves 94.8% retrieval accuracy while boosting long-horizon reasoning by 18.5% with 90% lower latency

The crazy part is how memory engineering solves the state decay problem in multi-bot setups like my Grok Bot research desk

The engine tracks bi-temporal timelines, invalidates outdated entity edges, and maintains persistent memory state across continuous research runs

Most multi-agent architectures dump unstructured research notes into static vector databases

This architecture turns agent memory management into a dynamic temporal graph system

Read the complete paper + article below

Bookmark it for future reference

[Matt Dancho (Business Science) @mdancho84]

🚨BREAKING: MIT researchers discover how to enable LLMs to do real logical reasoning.

This is what you need to know:

(thread)

[chuplung @choopyplug1]

Google's team just dropped a 9-page PDF on Harness Engineering - one formula replaced prompt engineering:

the twist: same Claude Sonnet, same benchmark - change only the harness

the formula: Agent = Model + Harness

here's the playbook in 6 steps:

step 1 → add guides - AGENTS.md, rule files, constraint docs - each line is a past agent failure turned into a permanent fix

step 2 → add sensors - linters, tests, validation scripts the agent runs on its own output before a human sees it

step 3 → build the agentic loop - plan, execute, verify, fix - bounded retries, budget caps, escalation when stuck

step 4 → externalize memory - the model forgets every session. the harness remembers state, decisions, and artifacts across all of them

step 5 → enforce permissions - which tools, how many writes, what needs approval. the model doesn't enforce safety. the harness does

step 6 → wire observability - track every tool call, cost, retry. trip wires fire when behavior drifts

the result: your agent stops being a demo and starts being infrastructure - every failure makes the system permanently better, not just the next conversation

this 9-page PDF is what comes after prompt engineering and context engineering

bookmark and build the full system from the article below ↓

[marfin @marfinxx]

This Google DeepMind paper is f*cking insane

Google researchers just proved that LLM reasoning verifiers are scoring the wrong metric

A new research paper proves that scoring step-level advantages instead of raw value functions unlocks 10x compute efficiency in test-time search and online RL

Process Advantage Verifiers (PAVs), complementary prover rollouts, and progress-driven step rewards across Gemma-2B to 27B architectures

math reasoning prompt → step candidate sampling → PAV progress advantage scoring → beam search pruning → verified optimal proof

Google introduced Process Advantage Verifiers (PAVs), replacing static outcome scoring with automated step-level progress measurement:

→ Step-Level Advantage vs Value Functions
Measures the relative change in success likelihood before and after taking a step, rewarding exploratory progress rather than exploiting familiar prefixes

→ Complementary Prover Policy Dynamics
Evaluates step advantages under an external prover policy (Best-of-K) with high distinguishability variance rather than relying on self-referential base policy signals

→ 10x Test-Time Beam Search Scaling
Prunes combinatorial solution spaces aggressively during inference, beating outcome reward models by over 8% in accuracy while cutting compute by 5x to 10x

→ 6x Sample-Efficient Dense-Reward RL
Provides dense step-level supervision for policy gradient training, delivering an 8x surge in Pass@N performance and discovering solutions to previously unsolvable math proofs

Hypothesis Verification & Empirical Results
Google hypothesized that rewarding step-level progress under complementary provers resolves the sparsity of outcome rewards and the exploitation trap of value-based PRMs. Practical validation across Gemma reasoning benchmarks confirmed the findings: beam search against PAVs achieved an 8.4% accuracy surge (+10x compute efficiency gain over ORM baselines) while scaling online RL sample efficiency by 6x

Scaling test-time reasoning is not about generating larger beams or training static outcome verifiers. The leverage comes from measuring step-by-step progress under complementary provers and filtering out dead-end search paths

Read the complete breakdown in the article below ↓

[marfin @marfinxx]

This Google AI research paper is f*cking brilliant

A new research paper proves that distilling high-level strategies from failed and successful trajectories transforms static LLMs into self-improving agents

ReasoningBank memory extraction, memory-aware test-time scaling (MaTTS), and failure-driven emergent strategy evolution across web and coding benchmarks

streaming task query → semantic memory retrieval → memory-guided rollout → LLM-as-a-judge signal → failure/success strategy distillation → consolidated memory bank

Google introduced ReasoningBank and MaTTS, establishing the first closed-loop architecture for memory-driven agent self-evolution:

→ Strategy-Level Reasoning Distillation
Replaces lossy raw trajectory dumps with structured reasoning items (title, description, decision rationale) that transfer across unseen websites and codebases

→ Counterfactual Learning from Failures
Extracts preventative rules and guardrails from self-judged mistakes, turning error traces into constructive signals that prevent repeating past failure loops

→ Memory-Aware Test-Time Scaling (MaTTS)
Leverages parallel self-contrast rollouts and sequential refinement to synthesize richer contrastive signals without burning compute on redundant paths

→ Emergent Behavioral Progression
Enables agents to autonomously evolve from low-level click procedures to adaptive self-checks and compositional multi-step verification over time

Hypothesis Verification & Empirical Results
Google hypothesized that structured reasoning memory distilled from both successes and failures creates a compounding flywheel when combined with test-time compute scaling. Practical validation across WebArena, Mind2Web, and SWE-Bench-Verified confirmed the findings: ReasoningBank drove a +20% relative success rate surge (BoN climbing from 39.0% to 55.1%) while slashing redundant interaction steps by 26.9%

Building lifelong autonomous agents is not about stuffing raw chat logs into long context windows. The leverage comes from distilling failures into actionable reasoning units and closing the loop between memory and test-time search

Read the complete breakdown in the article below ↓

[godhears @godhearsw]

This paper is holy insane.

Zhejiang University just dropped MemTrapBench, proving that agent memory can actually make models dumber.

By the numbers: adding memory frameworks caused every evaluated model (Gemini, Qwen) to drop 10% to 40% in performance compared to having NO memory at all.

The best part is cognitive traps: retrieved context creates "reasoning inertia," locking the agent into stale solution paths and completely blinding it to simple factorial logic or basic safety checks.

It exposes four major failure modes: Cognitive Bias, Task Boundary leakage, Trauma-induced tool avoidance from past negative feedback, and Safety hijacking.

While most dev teams blindly dump RAG and persistent history into their agents, this paper shows that uncurated context actively degrades System 2 reasoning.

It's a huge wake-up call: building production-grade agents requires adaptive memory pruning, not raw context retention.

Link to paper in comments.

Bookmark this, so that your agents don't become dumb.

[Superman @thesupermanmx]

Google DeepMind researchers argue we need to stop building LLMs..

They published a paper that proposes an alternative solution that changes everything.

LLMs are incredible at predicting the next token.

But they are fundamentally missing the core architecture of true intelligence. They lack persistent memory, an active world model, dynamic goal management, and continuous self-evolution.

They are a supercharged engine without a car.

The paper lays out the definitive shift we must make: Foundation Agents.

Instead of treating the LLM as the entire product, we have to move toward modular, brain-inspired architectures.

The new blueprint breaks AI down into distinct biological and cognitive systems:

• The World Model: An internal simulation to test consequences before taking action, rather than just guessing text sequences.

• Dynamic Memory & Perception: Persistent systems that learn, adapt, and evolve from real-world feedback rather than static pre-training data.

• Reward & Goal Processing: Systems capable of long-horizon autonomous planning instead of waiting for a human prompt.

• Collaborative Societies: Multi-agent ecosystems where intelligence emerges from negotiation, competition, and interaction rather than a monolithic chatbot.

The takeaway is brutally clear:

Scaling laws are flattening. Simply throwing more text at a transformer won't get us to AGI.

Paper: Advances and Challenges in Foundation Agents.. by researchers at Google DeepMind and leading AI labs.

[How To Prompt @HowToPrompt__]

Standford argues every major AI is secretly running at a fraction of their real creative capacity.

They call it “Mode Collapse." RLHF training strips out 76% of the model's creativity to make it sound "safer" to human raters.

And there's a one prompt that unlocks the version they hide from you.

Researchers published a paper proving why your favorite AI always feels predictable, repetitive, and boring.

During training, human annotators systematically favor familiar, safe, predictable text. They reward the model for blending in.

The technical term is “typicality bias.”

In plain English: human evaluators punish weirdness.

So the AI learns to water itself down. It defaults to the safest statistical middle ground. It buries its true generative diversity under layers of corporate polish.

You are not talking to a genius. You're talking to a crowd-pleasing filter.

But Stanford discovered you don't need to retrain the model to fix it.

They introduced a training-free strategy called Verbalized Sampling.

Instead of asking the AI for a single, safe answer, you force it to look at the entire probability tail of its own brain.

You change how you ask the question.

You prompt the model to generate multiple diverse responses along with their explicit probabilities, digging deep into the unconventional options it was trained to hide.

The results completely shatter the standard limitations.

Across creative writing, brainstorming, and complex problem-solving, Verbalized Sampling explodes output diversity by up to 2.1×.

It recovers over 66% of the raw, untamed creativity of the base model.

Without sacrificing factual accuracy. Without breaking safety guardrails.

The most powerful models on earth, GPT, Claude, Gemini, are locked inside a prison of corporate safety preferences.

They have the capability to surprise you. They have the raw intelligence to build entirely novel frameworks.

They just need you to stop asking for the safe answer.

[beamnxw ./ @beamnxw]

This paper is f*cking brilliant

A computer science survey mapped 150+ agent memory architectures across 90 pages to build self-evolving long-horizon agents

The result: a 3D taxonomy showing action-based memory and self-evolving structures boost long-horizon retention by 50%

The crazy part is memory is no longer just a passive database lookup

It also trains models to execute tool actions, update parametric weights, and consolidate episodic traces into skills

Most memory surveys analyze static database retrieval

This one maps the entire self-evolving agent operating system

Read the complete paper + article below

Bookmark it for future reference

[Xudong Han @Xudong07452910]

Agent 连续工作几个小时，真正难的是中途失败后，还能准确知道自己做到哪了。

阿里高德团队开源的 LongHorizon-Harness，专门解决长时任务中的状态漂移和错误累积。

它把执行过程拆成 Manage–Execute–Audit 循环：

Manager 根据已经验证的进度安排下一步；Executor 在全新上下文中操作桌面、浏览器或命令行；Auditor 再独立检查真实环境。

只有审计确认的结果，才会进入长期任务状态。遇到操作失败、上下文刷新或交付不完整时，Agent 可以保留已完成的部分，从缺口继续推进。

它也不绑定具体模型和后端，可以接入 Claude、GPT、Qwen，以及 Claude Code、Codex CLI、OpenClaw 等工具。

在相同的 Qwen 3.7-Plus 与 Claude Code 配置下，GUI 与 CLI 混合任务通过率从 51.8% 提升到 80.7%；OSWorld 完整完成率从 2.8% 提升到 8.3%；Terminal-Bench 成功率从 69.7% 提升到 77.2%，同时减少了 24% 的 token。

我觉得这篇最有意思的地方在于，它把长时能力的重点，从让一个会话持续运行，推进到了让每段进度都可验证、可恢复，也能可靠地交给下一轮。

模型决定单步能力，harness 决定这些步骤最后能不能拼成一个完整交付。

📎 arxiv: https://t.co/FrJld6UEJi

[Xiaochuan Li @xiaochuanlee]

Introducing ACM: Agentic Context Management for Long-Horizon Tasks.

ACM teaches agents when and how to manage context on its own — no forced compression, no loss of discarded details. It keeps short-term working memory clean and long-term external memory stable.
[1/9]

[How To Prompt @HowToPrompt__]

Stanford and Harvard answers the most important question in AI.

why most AI systems feel impressive in demos and then completely fall apart in real use?

Researchers published a massive definitive paper breaking down why this happens.

The root cause is a fundamental design flaw called the "adaptation gap."

Right now, builders treat AI agents like static software.

You take a frozen foundation model, write a clever system prompt, hook it up to a few APIs, and hope for the best.

It works fine in a sterile, predictable benchmark environment.

The moment it hits the messy, shifting reality of production, it breaks because it cannot adapt.

The paper introduces a unified framework showing that real, robust agentic systems require continuous post-training adaptation across two critical dimensions:

1. Agent Adaptation Fixing how the model learns from its own execution feedback. When a tool fails or an API throws an error, a static agent just loops or hallucinates a fix. True production agents need on-policy reinforcement learning and execution-signaled fine-tuning to actually learn from failure in real-time.

2. Tool Co-Adaptation This is where most systems fail completely. Builders assume tools are fixed. But real-world tasks require adaptive memory architectures and dynamic skill libraries that evolve
alongside the agent.

The paper maps out why static prompting and off-the-shelf wrappers hit a hard ceiling.

A demo is just a single scripted trajectory. Production is an infinite number of edge cases.

If your agent can't adapt its internal logic, memory, and tools dynamically after pre-training, it isn't an autonomous worker.

It’s just an expensive script with a random number generator.

The hype phase of agentic AI is over. The engineering phase of teaching agents how to actually learn from their mistakes has begun.

[How To Prompt @HowToPrompt__]

Google Deepmind argues that LLMs can never make real scientific discoveries.

They published a paper breaking down Albert Einstein’s private view of scientific discovery.

In a famous letter to his friend Maurice Solovine, Einstein drew a diagram of how science actually happens.

It is a cyclical loop.

First, you experience raw sensory data. Then, through a mysterious, non-logical act of intuition, you make an intuitive "jump" to abstract axioms. Finally, you use strict logical deduction to derive consequences from those axioms.

Generative AI has completely mastered two-thirds of this loop.

• Induction: Statistical pattern matching across billions of tokens.
• Deduction: Formal proof generation, like AlphaProof solving complex math Olympiads.

AI can crunch data and it can prove theorems.

But it cannot make the jump.

The paper argues that AI completely lacks Abduction, the generation of novel explanatory hypotheses when observational data is scarce.

The prevailing tech myth says that "creativity is just data compression." That if you feed an LLM enough text, scientific breakthroughs will naturally pop out.

Einstein’s formulation of General Relativity proves that is a delusion.

When Einstein formulated relativity, the observational data didn't demand a new physics framework; classical mechanics was still massively successful. The breakthrough required a conceptual rupture. An intuitive leap from physical reality to a brand-new set of foundational axioms.

An LLM can execute the math once the axioms are given. But it is structurally incapable of formulating those premises on its own.

It can interpolate inside existing human thought, but it cannot transcend it.

The translation of physical reality into formal axioms remains the absolute, hard bottleneck of artificial scientific invention.

We can build models with trillions of parameters. We can scale compute into the stratosphere.

We can make the calculator infinitely fast.

But until we solve grounding, the machine can process all the data in the universe.

It still can't make the jump.

[Leaf Meta 🇰🇷 @leafmeta]

📌 그래프 엔지니어링, 이제 말로만이 아니라 실제 도구로 나왔다 (메타인지로 근거 붙여봄)

•그래피파이 : AI 코딩 어시스턴트용 스킬, 코드베이스를 지식그래프로 통째로 매핑
•벡터인덱스아님 : 임베딩 없이 실제 그래프를 순회하는 방식
•반전포인트 : 코드 파싱은 LLM 안 씀, 완전 로컬 무료

1) 그래피파이라는 오픈소스 도구가 최근 화제임. AI 코딩 어시스턴트(클로드코드, 커서, 코덱스 등)에서 명령어 하나 치면 코드, SQL 스키마, 문서, PDF, 이미지, 영상까지 프로젝트 전체를 지식그래프로 만들어줌. 그담부터는 파일을 매번 grep하는 대신 그래프에 질문하는 방식으로 작업함.

2) 이게 그래프 엔지니어링 개념을 실제 도구로 구현한 사례임. 노드는 코드의 개념 하나하나, 엣지는 그 사이의 관계(호출, 상속, 참조)임. 근데 재밌는 게 코드 파싱 자체는 트리시터라는 파서로 로컬에서 결정론적으로 처리함, LLM 안 씀. 그래서 코드만 있는 프로젝트는 API 비용 0원임. 문서나 이미지처럼 의미 해석이 필요한 것만 LLM한테 넘김.

3) 벤치마크 수치도 근거로 붙일 만함. LOCOMO 데이터셋 기준 recall@10이 0.497로, 비교 대상인 다른 메모리 시스템(0.048, 0.149)보다 훨씬 높게 나옴. 그래프 빌드에 드는 LLM 크레딧은 0인데, 이건 코드 파싱 부분이 로컬 처리라서 가능한 수치임.

4) 반전 포인트. 다들 요즘 RAG 하면 벡터 임베딩부터 떠올리는데, 이 도구는 정반대 접근임. 임베딩도 벡터스토어도 없이 진짜 그래프 구조를 순회함. 그리고 모든 엣지에 “명시적으로 추출됐는지” “추론된 건지” 태그를 달아둬서, AI가 뭘 확실히 아는지 뭘 짐작한 건지 구분할 수 있게 해둠.

💬 정리하면, 프롬프트 잘 쓰는 시대에서 루프 설계 시대로, 이제 그래프 자체를 코드베이스에 적용하는 시대로 넘어가는 흐름이 실제 제품으로 나타난 셈임. 물론 이것도 아직 초기 도구라 대규모 레포에서 얼마나 안정적일지는 더 지켜봐야 함.

#그래프엔지니어링 #지식그래프 #클로드코드

🔗 참고한 정보: 코드는 트리시터로 로컬에서 무료로 파싱되고 임베딩 없이 실제 그래프를 순회하는 방식이다, https://t.co/FrXIvNq2Uf

[DAIR.AI @dair_ai]

Very cool idea to convert memory to skills.

(bookmark it)

Most agent memory systems retrieve past traces as passive context. MSCE turns them into executable skills instead.

The training-free framework organizes agent experience into grounded step traces, reusable procedural policies, and declarative environmental cognition. Evidence-backed policies with positive estimated gain get converted into callable skills that carry their applicability boundaries, verification rules, and reliability estimates. So a skill knows when it applies and how to check itself.

The other piece is reflection-weighted value backfilling, which propagates sparse terminal feedback through dense local self-reflections to produce evidence-calibrated trace values. Those values govern which memory and skills survive. On EvoAgentBench and LoCoMo, MSCE outperforms strong skill-augmented and memory-driven baselines with cross-domain transfer.

The gap between memory-as-context and memory-as-capability seems to be where long-horizon agents actually compound.

Paper: https://t.co/rXNkXqsXDx

Learn to build effective AI agents in our academy: https://t.co/LRnpZN7L4c

[Xiaoxi Li @XiaoxiLi0111]

AI agents are exhibiting remarkably long-horizon capabilities.

🚀 We release the first comprehensive survey on Long-Horizon Agents, framing long-horizon ability as the co-evolution of Harness × Optimization.

📄 Paper: https://t.co/9G0NrASvF2
⚙️Github: https://t.co/GCoVy3FfW4

[Ali Behrouz @behrouz_ali]

Moving from conventional ML to continual learning requires revisiting even the fundamental concepts such as “test”/“train” time.

LLMs Need Sleep and Dreaming! We introduce a phase, where the model consolidates its fragile short-term memories into stable long-term memories, and then dreams to recursively self-improve over time. For memory consolidation, we introduce a new form of distillation, called Knowledge Seeding (KS), where a small model(s) distills its knowledge to a larger model. Our experiments on continual learning and reasoning tasks show that this new phase can help the model to perform better and relatively better mitigates catastrophic forgetting.

[LinearUncle @LinearUncle]

推荐这篇文章
《斯坦福STORM方法：如何让Claude在几分钟内像博士一样做研究》

这篇文章介绍的斯坦福 STORM 方法，是一种能让你在几分钟内，利用 Claude 完成相当于博士级研究的提示词框架。其核心在于模拟多角色视角来消除研究盲点。

我建议提取提示词组合做成适合自己的SKILL.md让agent执行,这点原作者没有提到。