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?

Maria Vechtomova

Senior Machine Learning Engineer

Data & AI leader with 12 years of experience, devoted to MLOps. I’m principle-first and tool-pragmatic: I’ve evaluated many tools and platforms and built my own where it mattered.

My mission is to teach teams how to apply MLOps in practice, often using Databricks to make the principles concrete. I’m excited about Generative AI and view LLMOps as a natural extension of MLOps. Currently authoring an O’Reilly book and teaching MLOps courses online and on-demand.

Co-Founder

MLflow supports a wide range of flavors:

➡️  Classic ML flavors: sklearn, statsmodels, catboost, xgboost, and others.
For custom applications, pyfunc.PythonModel can be used.
When model logged with one of these flavors is deployed behind a model serving endpoint, MLflow serving payload is followed.

➡️  AI agents: dspy, langchain, llama_index. 
For custom applications, pyfunc.ResponsesAgent can be used. It follows OpenAI Responses API. 
Models logged with dspy and langchain flavor follow OpenAI Chat Completions API

➡️  Transformers flavor has its special place. 
You can download models from Hugging Face and finetune, then log providing the task type (that follow OpenAI Chat Completions API, OpenAI  Embeddings API, or legacy OpenAI Completions API). 
Only certain model families with certain configurations can be deployed through provisioned throughput.

Co-founder @Cauchy | Global speaker & advisor | MLOps Tech Lead | Writing a book for O’Reilly

We’ve received a lot of positive feedback on our MLOps with Databricks course on Maven. And yet, we decided to close it last year.

While traditional ML still delivers most of the real business value, the market has clearly shifted toward Agentic AI.

But MLOps didn’t disappear. If anything, it became more advanced, more complex, and more critical than ever. That’s where we kept seeing the same gap. Most courses teach you how to build agents, almost none teach you how to operate them in production.

So Başak and I decided to focus entirely on that gap. End-to-end LLMOps on Databricks, which is moving insanely fast in this space.

There’s currently no other course that focuses on Databricks and goes this deep, this practically, and this up-to-date on:
- Building agents on Databricks
- Operating them in real production environments
- Managing the full lifecycle around them

Bonus: you’ll also get full access to our MLOps materials.

We’re not planning to run this course again anytime soon, so grab this opportunity!

P.S. A few students ran into payment issues earlier, so we’ll have a 20% discount open until the end of January: https://lnkd.in/efAyrwE4

Model promotion vs code promotion is a hot topic in MLOps. Not so much in LLMOps.

For standard ML, you don’t always want to retrain your models in each environment, especially if it’s costly and slow. Train once, promote the artifact.

But this is way less relevant for AI applications. Most companies aren’t doing LLM fine-tuning.

Your AI application consists of artifacts like:
- Tool calling definitions
- LLM API calls
- Prompts
- Orchestration logic
- Vector search configuration
- Database for agent memory

Prompts and orchestration are universal, the rest is often environment-dependent. You have to rerun your code in each environment. 

There’s no model artifact to promote.

In this sense, AI applications are closer to regular software than traditional ML.

♻️ Repost if you found it useful!
🔔 Follow me, Maria, for more insignts on AI engineering and MLOps!

Alerts on Databricks are underrated.

You want to know as soon as possible if you've exceeded your budget, or if your model is no longer performing as expected.

Setting up an alert is now easy using Databricks Asset Bundles (DABs). In the example below, we deploy a serverless SQL warehouse and an alert that runs the specified query on schedule using that warehouse and sends notifications via email.

Email is just one option. Slack, PagerDuty, and MS Teams are supported out of the box, but any webhook will work.

One of the resources that is best deployed via DABs and not other options.

♻️ Repost if you found it useful!
🔔 Follow me, Maria, for more tips about Databricks, AI engineering, and MLOps!

Bringing the 2016 -> 2026 trend to LinkedIn!

2016 was awesome! 
- Visited many conferences (Pydata, Spark Summit, many Teradata events, and all the meetups I could find), and spoke at many events. A proof of me talking about MLOps here (using Aster! If you ever tried it, you can imagine how painful it was).
- Took all courses on data science and Python I could find
- Travelled a lot: Denmark, Italy, the US, Russia (2x, one of which for a conference), Germany, Spain.
- Saw my mom 3 times that year (I wish I could see her that often now!)
- Had a lot of fun with the dream team at KPN! Thanks to Thijs Voogt for being such an amazing manager!

I hope 2026 will be just as great! How was your 2016?

Claude meets JSON.

Building Databricks dashboards manually is tedious. Good news, they are represented as JSON files with SQL queries, and with Claude Code you can build and deploy the whole dashboard  in <1 hr.

Steven Kempers wrote an article on how to do it on Cauchy Substack: https://lnkd.in/etHPm4Gc.

Check it out and subscribe not to miss our next articles!

I love a good podcast. it's my go-to for turning drive time into learning time.

Recently, I had the pleasure of joining 🎙Patrick Akil on the Beyond Coding podcast, where we dug into a topic close to my heart: why bringing AI to production is so hard.

Most teams vastly underestimate what it takes. The shiny prototype gets all the attention. The messy reality of monitoring, cost management, and keeping AI systems reliable at scale gets ignored until it's too late.

Patrick is building something great with this podcast. Check out some of his other guests: Marijn Markus, Bassem Dghaidi, Arjan Egges, Alex Freberg. All worth a listen!

Link to the podcast: https://lnkd.in/etka8HpX
Also available via your favorite podcast platform.

taplio

The Battle

Pascal Biese

Maria Vechtomova

Followers

Posts

Engagements

Likes

Performance ScorePascal Biese's LinkedIn Performance

Performance ScoreMaria Vechtomova's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Pascal Biese

Maria Vechtomova

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 ScoreMaria Vechtomova's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScorePascal Biese's LinkedIn Performance