As the founder of LLM Watch, my goal is to curate the most relevant Large Language Model (LLM) research and make it accessible to a broad audience. 

I distill complex technical topics into summaries that respect your time. 

Before embarking on this journey, I led Deep Learning R&D at one of Europe's largest telecom companies. There, I spearheaded numerous AI projects with a focus on Natural Language Processing (NLP) and Automatic Speech Recognition (ASR). 

With more than 6 years of experience in AI, I was there before the hype. 

I try to offer a healthy balance between shiny new things and what really matters.

Pascal Biese

Self-Evolving Memory:

A new framework from OPPO AI and LV-NUS lab now introduces memory systems that evolve their own architecture.

The paper draws a compelling analogy to human learning. Most AI agents today are like students who know how to take notes, but always use the same study method regardless of the subject. MemEvolve creates "adaptive learners" that dynamically adjust their learning strategy based on what they're trying to accomplish - memorizing facts for one task, abstracting patterns for another.

For this, they developed a dual-evolution process. The inner loop accumulates experience within a fixed memory architecture. The outer loop does something more interesting: it evaluates how well that architecture is working and proposes structural modifications. 

The system decomposes memory into four modules - Encode, Store, Retrieve, Manage - and uses performance feedback to diagnose bottlenecks and redesign components accordingly. 

The results? MemEvolve improves agent frameworks like SmolAgent and Flash-Searcher by up to 17% on challenging benchmarks. And the memory architectures evolved on one task transfer effectively to unseen benchmarks and different backbone models, suggesting the framework discovers generalizable principles rather than task-specific heuristics. 

In addition to the paper, they also released EvolveLab which unifies twelve existing memory systems under a common interface, making this a practical foundation for future research on self-improving agents. 
↓ 
𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com 💡

AI Lead at PwC <​/​> Daily AI highlights for 80k+ experts 📲🤗

MemEvolve: Meta-Evolution of Agent Memory Systems

A DeepSeek moment for AI memory? 

DeepSeek AI just published research suggesting that modern language models are burning valuable compute simulating memory lookups through expensive neural operations.

The problem is fundamental: language modeling involves two very different tasks. One is compositional reasoning - connecting ideas, logical inference. The other is knowledge retrieval - recognizing "Diana, Princess of Wales" or common phrases. Current Transformers have no native mechanism to simply look up static patterns, so they're forced to reconstruct them through multiple layers of attention and feed-forward networks.

The proposed solution is called Engram, a "conditional memory" module based on N-gram embeddings that retrieves static patterns in O(1) time. The key insight is that it's about finding the optimal balance between conditional computation (MoE experts) and conditional memory. The researchers discovered a U-shaped scaling law: pure MoE isn't optimal. Reallocating roughly 20-25% of sparse parameters to memory yields superior results. 

While memory was expected to help knowledge-intensive tasks (MMLU +3.4), the largest gains appeared in reasoning (BBH +5.0) and code/math (HumanEval +3.0, MATH +2.4). Mechanistic analysis reveals why: by offloading pattern reconstruction, Engram effectively deepens the network - shallow Engram layers produce representations equivalent to much deeper MoE layers. 

Perhaps most practically significant: the deterministic addressing allows offloading 100B-parameter tables to host memory with less than 3% overhead. 

This suggests that the next generation of sparse models might not just be about smarter routing - but about recognizing that some knowledge simply doesn't need to be computed at all.
↓ 
𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com 💡

A New Axis of Sparsity for Large Language Models

Meta's Super Intelligence Lab just published their solution to the training data problem. 

Training search-augmented LLMs typically requires extensive human-annotated questions and answers. As high-quality data becomes scarcer and more expensive, this dependency creates a significant bottleneck for developing capable AI research agents.

Dr. Zero introduces a clever proposer-solver feedback loop. Both models start from the same base LLM, but play different roles: the proposer generates increasingly difficult questions, while the solver learns to answer them using external search. 

The key insight is that as the solver improves, easy questions stop providing useful training signal, which forces the proposer to generate harder ones. This creates an automated curriculum that pushes both models forward without any human data.

The computational challenge with such approaches is typically prohibitive. Standard reinforcement learning methods require sampling many questions and many answers per question, creating nested costs that explode for multi-turn reasoning. Dr. Zero solves this through Hop-Grouped Relative Policy Optimization (HRPO), which clusters questions by their structural complexity (number of reasoning "hops" required) and computes advantages within these groups. This reduces sampling overhead to roughly one-fourth of standard methods while maintaining performance. 

The data-free Dr. Zero matches or exceeds fully supervised search agents across seven QA benchmarks, with up to 14.1% improvements on complex multi-hop reasoning tasks. 

This suggests that complex reasoning and search capabilities can emerge purely through self-evolution. 
↓ 
𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com 💡

Self-Evolving Search Agents without Training Data

LLM-as-a-Judge -> Agent-as-a-Judge

Using LLMs to evaluate other LLMs seemed like a clever shortcut. But single-pass evaluation is hitting its limits: we need evaluators that can actually verify claims, not just assess how plausible an answer sounds. 

Traditional LLM judges are passive observers. They grade based on linguistic patterns without checking if the code runs, the math is correct, or the facts hold up. 

A new comprehensive survey traces the shift to Agent-as-a-Judge, where evaluation becomes an active, multi-step process. Instead of one model making a snap judgment, agentic judges decompose evaluation into subtasks, invoke external tools like code interpreters and search engines to verify claims, and use multi-agent debate to neutralize individual model biases. 

The researchers identify three developmental stages: procedural agents following fixed workflows, reactive agents adapting based on intermediate feedback, and self-evolving agents that can refine their own evaluation criteria on the fly. Applications already span code verification, fact-checking, medical assessment, legal judgment prediction, and financial research analysis. 

When AI systems are used to generate training signals for other AI systems, the precision of the judge determines everything downstream. Can we build evaluators that know when they need to verify rather than guess?
↓ 
𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com

A Survey on Agent-as-a-Judge

What if you could surgically edit an LLM's knowledge by swapping a single vector?

A new architecture from CMU and Meta AI makes this possible, while also solving some of the thorniest problems in scaling transformers.

Scaling language models has traditionally meant more compute. Mixture-of-Experts (MoE) promised a workaround by activating only a subset of parameters per token, but came with notorious training instability, load balancing headaches, and communication overhead that grows with expert count.

Instead of dynamic routing to experts, STEM (Scaling Transformers with Embedding Modules) replaces the FFN up-projection with a static, token-indexed embedding lookup. Each token has its own embedding per layer, while the gate and down projections remain shared. No routing decisions, no load balancing losses, no cross-device communication for expert selection. 

The results? 3-4% accuracy gains over dense baselines, with particularly strong improvements on knowledge-intensive benchmarks (9-10% on ARC-Challenge and OpenBookQA). Training remains stable where MoE would show loss spikes, and the architecture naturally activates more parameters as context length grows. 

Because each embedding maps to a specific token, you can literally swap "Spain" for "Germany" at the embedding level and watch the model output "Berlin" instead of "Madrid", without changing the input text at all. 

If interpretability and controllability matter as much as raw performance, STEM suggests we may have been overcomplicating sparse scaling all along.
↓
𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com

STEM: Scaling Transformers with Embedding Modules

The next big step in LLMs?

A new inference technique from Massachusetts Institute of Technology called Recursive Language Models (RLMs) is rethinking context windows entirely.

The core problem is well-known: even frontier models like GPT-5 suffer from "context rot" - performance degrades quickly as prompts get longer, regardless of the technical context limit. Summarization helps but loses critical details. Retrieval misses complex reasoning patterns. Have we been trying to make models see more, when perhaps the answer is to make them see differently?

RLMs treats the prompt not as direct neural network input, but as an external object the model interacts with programmatically. The prompt is loaded as a variable in a Python REPL environment, and the LLM writes code to peek into it, decompose it, and recursively call itself over smaller snippets. Same interface as a regular LLM, radically different execution.

On information-dense tasks where GPT-5 scores below 0.1%, RLMs achieve 58%. On multi-hop research questions spanning 6-11M tokens, RLMs hit 91% accuracy while costing less than feeding the full context would. Crucially, performance degrades far more gracefully as complexity scales - the approach handles inputs two orders of magnitude beyond native context windows.

This suggests that scaling context is not just an architecture problem but also an inference problem. RLMs demonstrate that letting models reason about their input symbolically rather than processing it neurally could be a promising new direction.

If this approach generalizes, we may be looking at a new axis for scaling language model capabilities entirely.
↓ 
𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com 💡

Recursive Language Models

The latest reasoning models fail on puzzles with just 1 unknown cell.

Yet they solve complex ones with dozens of steps.

New research reveals why: these models might be pattern matching, not actually reasoning.

Hierarchical Reasoning Models (HRMs) crush benchmarks, outperforming LLM-based reasoners by wide margins. But researchers dug into the mechanics and found something troubling.

Think of it like a student who memorizes exam answers. They ace questions they've seen before but stumble on trivially easy variations.

The researchers identified three failure modes:

- HRMs fail on extremely simple puzzles (single unknown cell) when patterns violate their training distribution
- Models lack the "fixed point property" - they can't recognize when a problem is already solved
- Performance doesn't correlate with puzzle difficulty the way true reasoning would

This matters because we're deploying these models assuming they generalize.

If your reasoning model solves a 50-step problem but fails a 2-step variant, it's not reasoning - it's sophisticated pattern matching.

Before trusting HRMs in production, test them on deliberately simple edge cases. The failures will tell you more than the successes.
↓
𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com 💡

Are Your Reasoning Models Reasoning or Guessing?

Anthony Alcaraz

Writes on ML/LLM Ops 🎨 | Follow me (4,8 K+) 🔔

I help AI startups go from promising to unstoppable.

I also write about it, my book Agentic Graph RAG (O'Reilly, 2026) is the practical blueprint for building AI systems that combine retrieval, reasoning, and autonomous decision-making at enterprise scale.

https://www.oreilly.com/library/view/agentic-graph-rag/9798341623163/

My career has been a journey across both sides of the table: building AI products as a CTO, transforming legacy systems as a Field CTO for enterprises and government, and now at AWS, helping the most exciting GenAI startups scale across Europe and the US.

I've shipped GenAI platforms, deployed MLOps pipelines serving millions, advised L'Oréal on AI-for-BI transformation, and lectured at Oxford on the intersection of LLMs and graphs. But what gets me out of bed is working with founders who are solving hard problems with bold ideas.

At AWS, I connect high-potential startups with the resources, partnerships, and enterprise pathways they need to grow. Before that, I was in the trenches, building, breaking, and shipping.

If you're a founder, VC, or enterprise leader thinking about GenAI, agentic systems, or knowledge graphs, I'd love to chat.

Chief AI Officer & Decision scientist

Management in AI Projects and Engineering Teams:
In my managerial role, I oversee AI projects and lead teams of engineers in crafting cutting-edge solutions. My focus is on driving strategic initiatives, ensuring projects are aligned with organizational goals, and fostering a culture of innovation and excellence. I take a hands-on approach to problem-solving and mentorship, ensuring that both projects and people reach their fullest potential.

Development in LLM/ML Ops:
My development expertise lies in the specialized domains of Large Language Models Operations (LLM Ops) and Machine Learning Operations (ML Ops). I am responsible for streamlining machine learning workflows from development to deployment. My work enables organizations to not only adopt but excel in leveraging machine learning technologies, facilitating continuous learning and adaptability across the board.

Marketing and Strategic Partnerships:
In the realm of marketing, I focus on building and nurturing strategic partnerships. My efforts are geared towards creating synergies with like-minded organizations and industry leaders. By forming valuable partnerships, I amplify brand visibility, foster innovation, and open doors to new business opportunities. The result is a win-win situation for all stakeholders involved, enhancing both market reach and impact.

The strongest multi-agent architecture has one rule:
No agent calls another agent. Ever. 💢 

Most agent systems work like phone calls. The orchestrator dials Agent A, waits, dials Agent B with the result, waits again. 

If B hangs up, everyone downstream sits in silence.

Queue-based architecture works like a mailroom. Agents subscribe to event streams. They listen for messages matching their capability. They process, drop output into the next queue. No agent knows another agent exists. The queue is the only shared interface.

Agent A publishes to topic:tasks.parsed.
Agent B subscribes to topic:tasks.parsed.
Agent B publishes to topic:tasks.enriched.
Agent C subscribes to topic:tasks.enriched.

No function calls between them. No shared state. No waiting.

A meta-orchestrator reads every topic. It holds the full pipeline schema. When Agent B crashes, messages pile up in tasks.parsed with no consumer.

It restarts B, scales a second instance, or reroutes. Other agents never notice.

Four layers make this work:

Layer 0 — STATE: External stores (database, graph). Events carry references, not payloads.
Layer 1 — EVENT BACKBONE: Kafka or Redis Streams. Durable, ordered, replayable event log.
Layer 2 — AGENTS: Stateless consumers. One capability each. Subscribe input, publish output. Errors to dead letter queue.
Layer 3 — META-ORCHESTRATOR: Reads ALL topics. Tracks events via parentId chains. Detects stuck agents, poison pills, throughput drops.

Confluent documents four patterns on this backbone: Orchestrator-Worker, Hierarchical, Blackboard, Market-Based. Kai Waehner pairs Kafka with Flink for stateful stream processing. Anthropic's MCP and Google's A2A route through the event broker, replacing point-to-point APIs.

The agent contract is minimal: subscribe to T_in, consume event with id/type/payload/metadata, transform, publish to T_out with parentId linking back. On failure, publish to T_dlq with error context.

Every agent becomes a 200-400 line module. Independently deployable. Independently testable. Replaceable without touching anything else.

Ali Pourshahid at Solace calls this the "agentic AI mesh." Alan Nichol at Rasa warns the alternative is a distributed monolith — agents calling each other are monoliths with extra network hops.

The queue turns coordination into infrastructure. Agents stop calling. They start listening.

Scaling Agentic Startups to Enterprise @AWS | Author of Agentic Graph RAG (O’Reilly) | Business Angel

Your systems of record are lying to your AI agents. 🎶 

Ask sales for ARR: one number. 
Ask finance: different number. 
Ask accounting: something else entirely.

Now tell an agent to "calculate ARR for the board deck."

Which number does it use? When systems drift by 3%, which one wins?

The fragility isn't your model. 

It's whether the agent pulled the right value from the right system at the right time.

🔴 The Core Problem

Your warehouse stores state. It doesn't store reasoning, the logic that connects state to action.
Semantic layers define "official_arr." They don't capture that for board decks you exclude trial ARR, or that finance wins when sales disagrees.
That knowledge lives in tribal memory. And agents can't access tribal memory.

🟡 What Agents Actually Need

Three capabilities your stack doesn't have:
Full recursion, traverse ownership chains of arbitrary depth. 
Ontological inference, derive facts not explicitly stored. PTIME complexity, guaranteed reasoning termination.

SQL can't do this. Standard graph databases can't either.

🟢 The Transition That Works

Most enterprises assume agentic AI requires data migration.

It doesn't.

One bank tried the migration path: 4 people, 1.5 years, still couldn't explain credit decisions.

Same bank with a reasoning layer over existing data: delivered in weeks. 17-minute decisions became 5 seconds.

Bring reasoning to your data. Not data to reasoning.

🔵 The Data Strategy That Emerges

You have two distinct problems requiring two distinct solutions.

1️⃣  Problem one: Your agents need real-time memory. Conversation state. Session context. The ability to blend graph traversal with vector similarity in a single atomic transaction. Data that changes millisecond to millisecond.

This is an operational data problem. SurrealDB solves it. One engine handling graph, document, vector, relational, and time-series with unified ACID guarantees. Your agent's working memory lives here. LIVE SELECT pushes changes instantly. No eventual consistency bugs between separate stores.

2️⃣  Problem two: Your agents need to reason over enterprise knowledge. Derive conclusions from facts spread across Snowflake, Databricks, Postgres, and Oracle. Provide proof trees auditors can verify. Handle recursive ownership chains of unknown depth. Infer what must exist even when data is missing.

This is a reasoning problem, not a storage problem. Prometheux solves it. Connects to your existing data infrastructure without migration. Executes Warded Datalog+/- with mathematical guarantees no warehouse can provide. When your compliance agent needs to explain why a credit decision was made, the proof tree traces from conclusion back to source facts automatically.

These layers don't compete. 

They compose.

Your warehouse remains the analytical source of truth. 
Your operational systems remain the transactional front door.

Scaling AI Startups to Enterprise @AWS | Author of Agentic Graph RAG (O’Reilly) | Business Angel

Context graphs exploded in January 2026. 🤯 

I synthesized 6 leading perspectives into one framework.

Here's what the smartest people in enterprise AI are actually saying:

1. Arvind Jain (Glean CEO) - "Capture the How, Not the Why"

Systems capture final states. But work happens in Slack, docs, and meetings.

The "why" is unobservable. The "how" leaves a digital trail.

Over many cycles, process traces approximate the why.

2. Jaya Gupta (Foundation Capital) - "Security Is Existential"

Decision traces are the moat, but only if you make them safe.

Four primitives needed:
→ Stable pseudonymization
→ Synthesis-level conflict checks
→ Real-time policy enforcement
→ Sanitization before indexing

"Agents collapse the security boundary that human judgment provides."

3. Anshul Gupta (Actively AI) - "Salesforce Has Lost the Deal"

Salesforce is a system of record, not a source of truth.

"Ask any sales leader how they get up to speed on a deal. Salesforce is the last place they'd look."

The right unit isn't the opportunity. It's the account.

Per-account agents compound. Workflow agents don't.

4. Justin Johnson (Run Data Run) - "The Hard Part Is the Clock"

Both ontology camps argue about nouns.

Meanwhile, agents fail because they can't tell time.

"Your CRM knows Sarah is a VP. It doesn't know she was a Director until June—which explains why Finance flagged the pricing exception."

Temporal validity is the missing layer.

5. Diego Lomanto (WRITER) - "Enterprise Brain Must Be Stateful"

Most enterprise AI is stateless, each query starts fresh.

Enterprise brains remember, connect, and compound.

"Being adjacent doesn't compound. To capture reasoning, you need to be there when the decision commits."

Marketing is the proving ground: high volume, inherent ambiguity, unique executions.

6. Dharmesh Shah (HubSpot) - "The Three-Car Garage Problem"

"Building context graphs when you haven't deployed agents at scale is like installing a three-car garage when you don't own a car."

Most companies still:
→ Struggling with basic data unification
→ Figuring out if AI can handle tier-1 support
→ Haven't deployed agents at scale

Context graphs are inevitable. The timing is the question.

Six critical gaps remain:

1. Governance: No confidence decay or contradiction detection
2.*Security: Decision traces harder to anonymize than documents
3. Continuity: Workflow agents don't compound
4. Temporality: Systems can't answer "what was true when?"
5. Statefulness: Most AI is stateless
6. Adoption: Prerequisites aren't met for most companies

The architectural truth:

Layer 7: Context Graphs (memory)
Layer 6: Individual Brain (assistants)
Layer 5: Skills (portability)
Layer 4: Tool Orchestration (typed graphs)
Layer 3: Context Layer (access)
Layer 2: Control Layer (correctness)
Layer 1: Structured Output (composability)
Layer 0: Agent Harness (reliability)

If any layer = 0, total value = 0.

Context graphs are Layer 7. Build from the bottom up.

taplio

The Battle

Pascal Biese

Anthony Alcaraz

Followers

Posts

Engagements

Likes

Performance ScorePascal Biese's LinkedIn Performance

Performance ScoreAnthony Alcaraz's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Pascal Biese

Anthony Alcaraz

Followers

Posts

Engagements

Likes

Performance Score.css-goub6s{font-size:var(--chakra-fontSizes-md);font-weight:500;color:var(--chakra-colors-gray-600);display:block;margin-top:var(--chakra-space-1);}Pascal Biese's LinkedIn Performance

Performance ScoreAnthony Alcaraz's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScorePascal Biese's LinkedIn Performance