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?

5X your AI & Data Science skills. Get free AI guides and resources ⬇️

I didn’t start in tech. I studied English Literature and thought I’d build a life around writing. But somewhere along the way, I got curious about how digital products are built. That curiosity slowly pulled me into the world of product building.

I began as a Product Analyst. I used every chance I got to ask questions, break things, fix them, and learn. Over time, I moved into an Associate Product Manager role. It wasn’t easy, but every small step added up.

These days, I explore AI tools almost every day. I’m fascinated by how they’re changing the way we work. I test AI agents, AI automations, and AI models just to see what’s possible. I also share what I learn on LinkedIn to help others in the same space.

Leon Jose

🚨 Stanford's $200,000 AI degree is now FREE (LIST OF ALL COURSES)


Stanford University just made their entire flagship AI curriculum free on YouTube.

(REPOST to help your network 💝)

These are the exact courses their students pay $200K for:

CS230: Deep Learning (Autumn 2025)
https://lnkd.in/dQ-DHdsJ

CS329H: ML from Human Preferences
https://lnkd.in/d_6GzDAr

CS25: Transformers
https://lnkd.in/dbMtpim5

CS231N: Deep Learning for Vision (2025)
https://lnkd.in/djXeGyse

CME295: LLM Evaluation (Autumn 2025)
https://lnkd.in/dTPTwh_M

CS336: Language Modeling from Scratch (2025)
https://lnkd.in/dthjnD7E

Here's the honest truth:

Stanford didn't do this from kindness.

They did it because the AI industry moved so fast that 4-year degrees can’t keep up.

By graduation time:
→ Tools have changed
→ Frameworks evolved
→ Job requirements shifted

The new reality:

AI careers aren't built in lecture halls.

They're built in public.

→ Learn by building
→ Share what you create
→ Get hired for what you ship

Your New Year challenge:

Pick ONE course from this list

Watch lecture 1 this weekend

Build something small by next week

Numbers don't lie. Shippers get hired.


👉 Follow gotspeed to grow your AI skills




---

taplio

The Battle

Pascal Biese

Leon Jose

Followers

Posts

Engagements

Likes

Performance ScorePascal Biese's LinkedIn Performance

Performance ScoreLeon Jose's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Pascal Biese

Leon Jose

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 ScoreLeon Jose's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScorePascal Biese's LinkedIn Performance