Paper

Notion writeup

Code

Most reasoning models today rely on outcome-based RL: generate a solution, check if the answer is correct, and reinforce the whole trajectory. As reasoning becomes longer, the learning signal collapses - important steps and irrelevant tokens receive the same credit, and performance plateaus.

FIPO addresses this directly by introducing token-level credit assignment based on future impact. This turns a sparse, outcome-only signal into a dense, structured one. The authors train Qwen2.5-32B-Base on top of the DAPO recipe inside VeRL and evaluate on AIME 2024. They report Pass@1 going from 50.0% (DAPO) to a peak of 58.0%, converging around 56.0%. Response lengths roughly double during training, from around 4k tokens to more than 10k.

FIPO

FIPO measures, for each token, how much the policy’s behaviour on the rest of the rollout has shifted since the last update. For each position in a response, the authors compute the log-ratio between the current and old policy at every subsequent position, then sum these shifts with a discount factor that decays with distance. This is the Future-KL: a per-token statistic that measures how much the policy’s behaviour on the tail of the rollout has moved since the last update. Closer future tokens matter more than far ones. The discount works as a soft half-life rather than a hard cutoff.

Future-KL can be unstable due to distributional shifts, so it needs some mechanisms to avoid destabilizing the training process. First, a dual-clip mask zeroes out tokens whose importance ratio exceeds a threshold around 10, so that extreme values don’t hurt the gradients. Second, the future-KL value is mapped through an exponential clip into a bounded influence weight. Tokens whose future trajectory shifted a lot after the update receive larger effective advantages; tokens that did not move the future of the rollout receive less weight.

Experiments

• FIPO: 58.0% peak, around 56.0% at convergence.
• DAPO baseline on Qwen2.5-32B-Base: 50.0% Pass@1. Reproduced DeepSeek-R1-Zero-32B: ~47%.

Both DAPO and FIPO show length growth, but the FIPO curves are longer at the same step count. That is consistent with denser credit letting the model commit to longer reasoning - useful tokens in the middle of a rollout can now be rewarded directly.

The main drivers of FIPO’s effectiveness are: the emergence of length-based scaling in reasoning chains, the positive learning signal, and the significantly improved stability of the optimization process.

Limitations

• Compute overhead from per-step future-KL accumulation and 10k-plus rollouts;
• Narrow task scope (math reasoning only);
• Fixed dataset (DAPO’s open math corpus, not scaled up);
• A base-model confound that makes it hard to isolate the contribution of the RL recipe from the underlying pretraining and SFT.

Conclusions

FIPO targets a different problem compared to methods like GRPO, DAPO, and recent reasoning systems (DeepSeek-R1, o-series). Most existing approaches improve reasoning by scaling models, improving sampling or refining reward signals. FIPO instead changes how the reward is distributed within a trajectory.

This makes it fundamentally different:

• Compared to GRPO/DAPO, it removes uniform credit assignment
• Compared to PPO-style RLHF, it avoids critics while still providing dense signals
• Compared to top reasoning models, it suggests gains can come from training signal design, not just scale

I am less sure how well the gains hold up outside AIME or under a compute-matched comparison. The short-horizon future-KL proxy probably rewards some variance that is not reasoning-relevant. For now, it looks like a promising direction for reasoning-specific training rather than a drop-in upgrade.

Amazon

I was offered an opportunity to read Unlocking Data with Generative AI and RAG, Second Edition, by Keith Bourne, in exchange for an honest review. I reviewed the first edition back in 2024 and liked it, so I was curious to see how the second edition would handle the fact that RAG has since absorbed an entirely new layer of the stack — agents, graph retrieval, semantic caches, and memory systems. The book covers the modern RAG landscape across 20 chapters in three parts: classical RAG foundations, production-grade retrieval and evaluation, and an entirely new Part III on agentic RAG spanning LangGraph, ontology-driven graph RAG with Neo4j, semantic caching, and the CoALA memory framework. I liked this book, and its biggest strength is the continuous running example that carries you from a basic retriever in Chapter 2 all the way to a stateful, learning agent in Chapter 19 — a thread very few books manage to present.

The overall structure

The book is organized into three parts:

• Part I (Chapters 1–6) introduces RAG and its vocabulary, gets a complete pipeline running by Chapter 2, and then layers in practical applications, a security chapter with red and blue teaming, and a Gradio UI for demos.
• Part II (Chapters 7–11) goes deeper into the components: vectors and vector stores, similarity search, evaluation with Ragas, the LangChain retrievers and integrations, and the loaders, splitters, and output parsers that hold a real RAG system together.
• Part III (Chapters 12–19) is where the second edition contributes the most: agents and LangGraph, ontology engineering with Protégé, graph RAG on Neo4j, semantic caching, the CoALA memory framework, and a capstone investment-advisor agent that integrates all four CoALA memory types.

The implementations use real libraries rather than building everything from scratch, which mirrors how most teams actually work and saves the reader from the usual from-scratch boilerplate.

What I liked

There were many things I liked in this book, and I want to highlight several in particular:

• The single running example is used throughout all 20 chapters. I’ve read enough ML books where each chapter is its own throwaway notebook, so I really appreciate it when one isn’t, and the continuity makes it easier for me to follow the ideas presented in the book.
• The small but important Chapter 3 detail of returning sources alongside answers. Until we have full trust in LLM, being able to answer the question “where did this answer come from?” is very important.
• Chapter 9’s evaluation is built around Ragas — faithfulness, answer relevancy, context precision, context recall, plus direct insights from a Ragas co-founder. A lot of evaluation work happens after deployment, which matches my experience on several real projects.
• Chapters 13–14 guide you from building a financial ontology in Protégé to loading it into Neo4j with hybrid embeddings that blend text and graph structure. Designing a clean ontology has the same slow, painful, valuable feel as the months we spent organizing data labeling on one of my past projects: it is the kind of upfront work that pays off everywhere downstream.
• The Chapter 5 red team / blue team prompt-injection lab. Security chapters in ML books usually read like policy documents, while this one actually has you attacking and defending your own RAG pipeline, which is a much better way to build practice.

The standout production chapter for me was Chapter 15 on semantic caches. The long-tail framing of real-world queries, the cross-encoder verification step, the adaptive thresholds, and the eviction policy discussion are exactly the level of detail that separates a toy semantic cache from one that won’t embarrass you in production. Chapter 16 had a great comparison of three agentic memory frameworks: Mem0, LangMem, and Zep/Graphiti. And Chapter 19 brings everything together into a capstone investment-advisor agent that uses working, episodic, semantic, and procedural memory simultaneously.

What could have been better

There are a few small things that could have been handled differently:

• Failure modes are under-discussed. Almost every chapter sells the upside of its technique and skips what breaks. Agents make systems slower and harder to debug, cached answers can become stale, and memory stores can grow in ways that hurt retrieval. Such a comprehensive book could be more honest about the failure side, and I’d love a “what goes wrong” subsection in each Part III chapter in a future edition.
• A few places could use head-to-head numbers. When graph-based RAG is introduced, or when the memory-equipped agent is presented, I’d have liked even one quantitative comparison against a simpler baseline on the same questions — the architectures are convincing in concept, and a small numbers-on-a-table moment would make them convincing in practice too.
• The introduction chapter includes a table listing popular models and their context lengths for October 2025 – some of these models were already outdated at that time.

But these are small nitpicks that are completely overshadowed by the good sides of the book.

Conclusion

This book is a good fit for RAG practitioners past the hello-world stage — people who already know what an embedding is and what a retriever does, and who now want to go beyond basic vector search. It is particularly useful for engineers being asked to turn a working RAG prototype into something that handles evaluation, security, caching, and agentic workflows without falling apart in production. If you already own the first edition, the question is whether Part III is worth the upgrade, and the answer is yes — Chapters 12 through 19 are essentially a self-contained book on agentic RAG, and very few other resources cover this terrain end-to-end with working code.

RAG is moving fast, and any book on the topic will age quickly in its specifics — LangChain APIs will churn, new memory libraries will appear, and several embedding-model tables will look dated within a year. The value here is less in the details of any particular notebook and more in the mental scaffold: how retrieval quality connects to evaluation, how agents extend the RAG loop, why memory systems matter once an agent lives longer than a single turn, and where graph-based retrieval earns its weight. That scaffold holds up, even as the field continues to evolve.

Amazon

Author’s LinkedIn page

I was offered to read A Practical Guide to Reinforcement Learning from Human Feedback by Sandip Kulkarni in exchange for an honest review. The book covers the full RLHF pipeline across 12 chapters: from classical reinforcement learning through reward modeling and PPO-based fine-tuning, and then into newer methods like DPO, RLAIF, and Constitutional AI. I liked this book and consider it to be a well-structured learning resource providing good theory basics and a lot of practical examples.

The overall structure

The book follows a deliberate three-stage progression:

• Explaining the core principles of reinforcement learning and policy optimization
• Building a complete RLHF pipeline for LLMs
• Exploring the evolution of alignment research

By the time you reach DPO in Chapter 10, you understand why it exists, because you have already built a reward model, dealt with PPO’s clipped objective, and seen the full canonical RLHF loop in action. That kind of understanding is hard to get from blog posts or paper summaries alone.

I also liked that the implementations use real libraries (TRL, PEFT, Hugging Face ecosystem) rather than building everything from scratch. In industry, we use existing tooling to avoid bugs and save time, and the book does the same. The memory optimization advice scattered through the middle chapters (gradient checkpointing, staged model loading, working within Colab constraints) is the kind of practical wisdom that many books skip entirely.

What I liked

There were many things in this book that I liked, and I want to highlight several in particular:

• The discussions on annotator bias and labeling evaluation were especially interesting for me, as on one of my projects, we spend months on organizing data labeling
• Using human keyboard inputs for Mountain Car demonstrations was fun
• The code walkthroughs for configuring PEFT and LoRA were highly practical and well-written
• Using smaller models like Qwen2-0.5B-Instruct makes it easier to play with them when you don’t have good enough hardware for larger models
• The visualizations explaining the intuition behind the algorithms were great.

Chapters 9–12 are very interesting and useful; they cover modern approaches and offer many practical tips. The Constitutional AI section includes deployment architecture, transparency mechanisms, and governance considerations that feel like they were written by someone thinking about production systems, not just research experiments. The comparison between DPO and PPO trade-offs is well-argued and clearly presented. The evaluation chapter tackles genuinely hard problems (self-preference bias of LLM judges, mode collapse, the difficulty of proxy evaluations) without pretending there are clean answers.

What could have been better

There are some things that could have been handled differently or better:

• I’m not sure if it was necessary to explain self-attention and transformers in such detail.
• The TRL library versions are inconsistent across chapters, and since TRL’s API changed significantly between these versions, it would be great if all chapters used the latest version.
• I’d love to see some examples of UI/UX for data collection and user annotation.

But these are small nitpicks that are completely overshadowed by the good sides of the book.

Conclusion

This book is a good fit for ML practitioners seeking a single, structured resource that covers the RLHF landscape from foundations to modern methods. It is particularly useful for people transitioning into post-training roles, or for anyone who learns better from implementations than from papers. The code is reproducible, the tooling is up to date, and the pedagogical progression genuinely helps build intuition.

RLHF is moving fast, and any book on the topic will age quickly in its specifics. The value here is less in the details of any particular implementation and more in the mental scaffold: what reward models do, why evaluation is hard, how newer methods relate to older recipes, and why alignment is an engineering discipline rather than a collection of tricks. That scaffold holds up, even as the field continues to evolve.

Three years ago, I wrote about creating this website using Jekyll, GitHub Pages, and a custom domain. That post is still one of the most-read things on my blog. The site served me well since then — it helped during job interviews, got me a few consulting projects, and became a home for 190+ ML paper reviews.

But I felt that by early 2026, the site was in need of a refresh:

• Some content was outdated (About and Career pages weren’t updated for years)
• Some pages weren’t structured well (Actitivies page was a flat chronological list, Projects page had exactly two entries, Tags page was a wall of unsorted tags)
• And the site itself lacked many basic features, like search or dark mode support

I did the redesign in two waves. I started with infrastructure improvements (search, dark mode, structured data, footer, sharing). Then I did a full content and layout overhaul using Claude Code.

Wave 1: infrastructure improvements

Before touching any content, I wanted to fix the technical foundation. It took several sessions to make them.

Full-text search

The site had no search functionality at all. With 190+ posts, finding something specific meant scrolling through the blog listing or using the browser’s Ctrl+F on the tags page. I added a client-side search powered by a JSON index file that Jekyll generates at build time. The search modal opens with Ctrl + K (or Cmd + K on Mac) and supports multi-term filtering across titles, descriptions, tags, and content.

The search index is generated by a search.json file with Liquid:

[{% for post in site.posts %}
  {
    "title": {{ post.title | jsonify }},
    "url": "{{ post.url }}",
    "date": "{{ post.date | date: '%b %d, %Y' }}",
    "description": {{ post.description | jsonify }},
    "tags": {{ post.tags | jsonify }},
    "content": {{ post.content | strip_html | truncatewords: 50 | jsonify }}
  }{% unless forloop.last %},{% endunless %}
{% endfor %}]

The JavaScript fetches this JSON once on the first search, then filters locally. It is not as powerful as Algolia or Lunr, but it works well enough for a static site with a few hundred posts and requires no external service.

Dark mode

The site already had a basic dark mode toggle from an earlier refactor, but it was incomplete — many elements (code blocks, tables, form inputs, the career timeline) still used hardcoded light colors. I expanded the dark-mode.css file from about 100 lines to over 250, covering every component on the site. The dark mode toggle also needed to sync with the Utterances comment theme, so switching to dark mode now sends a postMessage to the Utterances iframe:

const updateUtterancesTheme = (theme) => {
  const utterancesFrame = document.querySelector('.utterances-frame');
  if (utterancesFrame) {
    utterancesFrame.contentWindow.postMessage(
      { type: 'set-theme', theme: theme },
      'https://utteranc.es'
    );
  }
};

Speaking of Utterances — the comments had an embarrassing bug. The comment section did not appear at all until you manually refreshed the page. The cause was that the site uses AJAX navigation (via History.js in personal.js), so navigating to a post did not trigger a full page load. The Utterances <script> tag was embedded inline in the post layout, and inline scripts only execute on initial load — AJAX page transitions skip them entirely. The fix was to replace the inline script with a placeholder <div id="utterances-container"> and move the Utterances initialization into personal.js, where it runs on every page transition.

This also handles the initial dark mode state — the theme is read from localStorage at injection time, so comments load with the correct theme from the start. The postMessage approach described above is still needed when the user toggles dark mode while comments are already visible.

Structured data and OpenGraph

I added JSON-LD structured data for both the site (WebSite schema) and individual blog posts (BlogPosting schema). The blog post schema includes headline, description, author, publication date, and keywords from tags:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Redesigning My Personal Website with Claude Code",
  "description": "A practical walkthrough of redesigning a Jekyll personal website — adding search, dark mode, structured data, and a full card-based redesign using Claude Code. What changed, what broke, and what it is like to iterate on a site with an AI coding assistant.",
  "datePublished": "2026-03-23T00:00:00+00:00",
  "author": {
    "@type": "Person",
    "name": "Andrey Lukyanenko",
    "url": "https://andlukyane.com/"
  },
  "keywords": ["blogpost","career"]
}
</script>

I also added missing OpenGraph tags (og:url, og:type) and a Twitter Card twitter:site tag. These are small changes, but they improve how links appear when shared on LinkedIn, Twitter, and other platforms. The og:type dynamically switches between article for blog posts and website for other pages.

Floating share bar and footer redesign

Blog posts got a floating share bar on desktop — four social buttons (Twitter, LinkedIn, Facebook, Reddit) that appear when you start reading and disappear when you scroll past the article. The visibility is controlled by checking the article’s bounding rectangle on the scroll:

function check() {
  var rect = article.getBoundingClientRect();
  var show = rect.top < window.innerHeight * 0.3
          && rect.bottom > window.innerHeight * 0.5;
  bar.classList.toggle('visible', show);
}
window.addEventListener('scroll', check, { passive: true });

The footer was redesigned from a single-column layout to a three-column grid (about, quick links, social icons) using CSS Grid. I also added proper focus-visible styles for accessibility across all interactive elements.

Wave 2: content and layout overhaul with Claude Code

With the infrastructure in place, the site still had the same content problems: outdated positioning, buried content, and flat hierarchies. For this part, I used Claude Code to do the whole thing in a single session (not one-shot).

Gathering ideas

First, I prepared a list of what I wanted to change myself, then asked three AI assistants (ChatGPT, Claude, Gemini) to analyze the live site and suggest improvements. All three converged on the same core problems: the strongest professional signals were buried or absent, good content was difficult to find, and some content was years out of date. I saved their suggestions into Markdown files, compared the overlapping recommendations, and wrote a combined improvement plan.

About page

The old page was a chronological autobiography. The new page is structured as a hub: a short intro, a row of credential badges, a horizontally scrolling “Latest Paper Reviews” section, curated “Featured Work” and “Beyond Work” card grids, and a collapsible section for fun facts at the bottom.

The “Latest Paper Reviews” section autopopulates using a Liquid include:

{% assign reviews = site.posts | where_exp: "post",
    "post.tags contains 'paperreview'" %}
{% for post in reviews limit:3 %}
<a href="{{ post.url }}" class="card">
  <div class="card__meta">{{ post.date | date: "%b %d, %Y" }}</div>
  <div class="card__title">{{ post.title }}</div>
  <div class="card__description">
    {{ post.description | truncate: 140 }}
  </div>
</a>
{% endfor %}

The horizontal scroll is done with pure CSS using flexbox and overflow-x: auto:

.card-scroll {
  display: flex;
  gap: 20px;
  overflow-x: auto;
  scroll-snap-type: x mandatory;
  -webkit-overflow-scrolling: touch;
}

.card-scroll .card {
  min-width: 280px;
  max-width: 340px;
  flex-shrink: 0;
  scroll-snap-align: start;
}

The main technical challenge was that Jekyll refused to process Liquid tags in the root index.html. After debugging, the cause turned out to be a quirk of how Jekyll handles root-level files — possibly a conflict with the paginator plugin. The fix was moving the homepage to _pages/home.html with permalink: /. Not obvious, and the kind of thing that wastes hours.

Card component system

Most visual changes are built on a reusable CSS card system (css/cards.css, 237 lines). The core card is a simple flexbox column with a hover effect:

.card {
  background: var(--background-alt-color, #f4f5f6);
  border-radius: 8px;
  padding: 24px;
  transition: box-shadow 0.3s ease, transform 0.2s ease;
  display: flex;
  flex-direction: column;
}

.card:hover {
  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.1);
  transform: translateY(-2px);
}

Cards are placed in responsive grids that go from one column on mobile to two or three on desktop:

.card-grid {
  display: grid;
  grid-template-columns: 1fr;
  gap: 20px;
}

@media (min-width: 768px) {
  .card-grid { grid-template-columns: repeat(2, 1fr); }
}

@media (min-width: 1024px) {
  .card-grid--3 { grid-template-columns: repeat(3, 1fr); }
}

Tag chips are small pill-shaped links that appear on cards and in the blog listing:

.tag-chip {
  display: inline-block;
  font-size: 12px;
  padding: 4px 10px;
  border-radius: 12px;
  background: var(--background-color, #ffffff);
  color: var(--text-light-color, #6B7B8D);
  border: 1px solid var(--border-color, #dddddd);
  transition: background 0.2s ease, color 0.2s ease;
}

a.tag-chip:hover {
  background: var(--accent-color, #3498db);
  color: #ffffff;
  border-color: var(--accent-color, #3498db);
}

Everything uses CSS custom properties, so dark mode works automatically.

Blog listing tag chips

Every post in the blog listing now shows up to four clickable tag chips. The first attempt had an interesting bug: the entire blog post card was clickable via a jQuery handler in personal.js, so clicking a tag chip navigated to the post instead of the tag page. The fix was a guard in the click handler:

$(document).on('click', '.post', function (e) {
  if ($(e.target).closest('.tag-chip').length) {
    return;  // let the tag link handle its own navigation
  }
  // ... existing post navigation code
});

Other pages

I restructured the Activities page from flat collapsible lists into cards for publications and talks, data tables for Kaggle notebooks and competitions, and compact inline archives for the full talk history. The Projects page went from two entries to eight, organized into Featured Projects (with images), Production ML, and Tools and Writing. The Tags page now groups 120+ tags into 12 thematic categories displayed as a two-column card grid, and individual tag pages show posts as cards instead of plain lists.

Working with Claude Code

Most of the changes were done in a single Claude Code session over a couple of days. The most useful pattern was version comparison: for each major page redesign, I asked it to create three versions at temporary URLs (/about-v1, /about-v2, /about-v3), previewed them all in the browser, and described which elements to combine. It is faster to compare three concrete implementations than to describe an abstract preference in words. One version could have a better visual appeal, another one - better structure, another one - a new useful feature, and so on.

Not everything worked well on the first attempt; I had to spend considerable time on debugging and testing. For the Liquid processing issue, Claude Code tried several approaches — adding layout: page to the front matter, moving Liquid into an include file, and finally identifying that the _pages collection was the correct fix. It diagnosed problems by inspecting the built _site/index.html output and checking whether Liquid tags had been resolved. For the tag chip click issue, it found the jQuery handler, understood the event propagation, and added the guard.

All content decisions were mine — which posts to feature, what texts to write, what to include or exclude. Some CSS required several iterations because I could see the rendered result, but Claude Code could only verify by grepping the HTML output. When I sent screenshots of broken layouts, it could usually identify the issue, though not always on the first try. It also occasionally generated text that was too promotional, which I had to tone down.

Summary of changes

Conclusions

The site now reflects where I am in 2026 rather than where I was in 2021 or 2023. The design is still built on a purchased Jekyll theme with incremental modifications, but it is much better at helping people discover useful content. For me, this is good enough.

Additionally, this was an interesting exercise in using AI to improve a personal website. I remember that it took me almost a month to set up the initial version, then days or weeks to make specific changes because I didn’t know web development well enough. This redesign took less than a week in total, and I learnt a lot about using AI and web development.

Paper

Project

Modern reinforcement learning pipelines for large models are usually isolated: each model generates its own rollouts, evaluates them with a reward model, and updates its policy independently. This setup is inefficient because different models often explore different parts of the solution space, but their discoveries remain locked inside each training run.

This paper explores a different idea: what if multiple heterogeneous models could learn from each other during training? HACRL (Heterogeneous Agent Collaborative Reinforcement Learning) enables multiple models to share successful trajectories while remaining independent during inference. The key algorithm, HACPO, enables this rollout sharing while correcting for policy mismatch between agents. In practice, this collaborative training improves reasoning performance and reduces rollout costs compared to standard RL approaches such as GSPO. The result is a simple yet powerful shift: instead of training models in isolation, HACRL lets them improve collectively through shared exploration.

Heterogeneous Agent Collaborative Reinforcement Learning

Most reinforcement learning pipelines train models separately; this means that even if multiple models are trained on the same task, their discoveries remain separate. One model might find a useful reasoning strategy, but other models never benefit from it.

HACRL proposes a different approach: multiple heterogeneous agents collaborate during training by sharing successful trajectories. The agents differ in architecture, size, or capability. When a model discovers a high-quality solution, the trajectory is shared with the others, allowing them to learn from that experience. The collaboration happens only during training - at inference time, each model still operates independently.

Having models of different capabilities means that using their trajectory naively by other models can introduce bias or destabilize learning. HACPO addresses this using two mechanisms:

• Exponential importance sampling adjusts the learning signal based on how compatible a shared trajectory is with the agent’s own policy: trajectories that look plausible receive stronger weight, while very unlikely ones have their influence reduced.
• Stepwise clipping further stabilizes training by limiting how large the policy ratio can become at each step of the sequence, preventing extremely unlikely tokens from producing large gradients.

The result is a collaborative training loop where agents both explore the problem space independently and learn from each other’s discoveries. Stronger models may uncover effective reasoning strategies, while weaker models contribute additional exploration diversity. Instead of repeating the same exploration across multiple training runs, HACRL turns training into a shared learning process, improving both performance and sample efficiency.

Experiments

The experiments evaluate HACRL using multiple heterogeneous language models collaborating during reinforcement learning. The results show that collaborative training consistently improves reasoning performance compared to standard single-agent RL optimization.

In particular, HACRL outperforms strong baselines such as GSPO, while requiring significantly fewer rollout samples. The gains are especially noticeable when agents have complementary capabilities: stronger models help guide exploration, while weaker models contribute additional trajectory diversity. These results suggest that shared exploration across models can improve both performance and training efficiency, supporting the central idea behind collaborative reinforcement learning.

Conclusions

Traditional RL post-training methods such as PPO, GRPO, or GSPO optimize each model independently using its own rollouts. Knowledge distillation allows models to learn from others, but information typically flows in one direction—from teacher to student. Multi-agent reinforcement learning trains multiple agents together, but those systems usually require joint deployment or shared policies.

HACRL proposes a different design: collaboration during training, independence during inference. Models exchange useful experience without becoming dependent on each other. This makes the approach particularly attractive in modern AI ecosystems where many models coexist. Instead of competing for training data, models can collectively explore the solution space and accelerate learning.

Paper

Code

Project

Modern LLMs struggle to generalize to sequences longer than their pretraining context, they typically require expensive long-context fine-tuning or architecture changes to extend usable context length. DroPE challenges this paradigm by removing positional embeddings after training and showing that while explicit positional biases aid convergence, they are not fundamentally needed at test time and, in fact, limit generalization to longer sequences.

The core insight is simple but counterintuitive: while positional embeddings (Rotary Positional Embeddings) accelerate early training by providing inductive structure, they become a bottleneck for generalizing to longer contexts. After a brief recalibration phase with positional embeddings dropped, pretrained LLMs exhibit zero-shot context extension far beyond their original sequence length without compromising performance on standard tasks. DroPE outperforms prior positional scaling methods and specialized architectures across different models and datasets at a fraction of the cost.

Explicit positional embeddings are beneficial for training

Although NoPE (No Positional Embedding) transformers are theoretically as expressive as RoPE models (they can reconstruct positional information using the causal mask), they consistently train worse in practice. Empirically, NoPE models show higher perplexity throughout training.

The authors argue that the difference is not about expressivity, but optimization dynamics. In NoPE transformers, positional information and attention non-uniformity (diagonal or near-diagonal attention patterns) develop only gradually because the gradients driving positional bias are bounded and small at initialization. Explicit positional embeddings like RoPE, however, inject strong positional bias from the start, enabling faster formation of useful attention patterns and more efficient training.

This means that NoPE can represent position, but learns it too slowly, while RoPE provides an inductive bias that accelerates training by immediately shaping attention toward position-sensitive structures.

RoPE prevents effective zero-shot context extension

RoPE scaling methods such as YaRN can maintain stable perplexity on longer sequences, but they fail to truly generalize beyond the training context: on downstream tasks, they behave similarly to simply cropping inputs to the original context length, effectively ignoring information that appears far into the sequence. This failure is clearly visible in long-context retrieval tasks like needle-in-a-haystack, where important distant information is missed despite unchanged perplexity.

The reason is frequency compression, which is unavoidable in RoPE scaling. To keep positional phases within the training distribution, all post-hoc scaling methods must aggressively compress low frequencies. However, low frequencies are primarily used by semantic attention heads, not positional ones. As a result, scaling leaves positional (high-frequency) heads mostly intact but warps semantic attention at long distances, increasingly so as sequence length grows. This shifts attention away from the correct tokens in long-range settings, explaining why RoPE scaling cannot deliver true zero-shot context extension.

DroPE: Dropping positional embeddings after pretraining

The conclusion is that positional embeddings are crucial for efficient language model training, but they fundamentally limit long-context generalization. The key insight is that positional information is needed only during training, not at inference.

Based on this, the authors introduce DroPE, a simple procedure that removes all positional embeddings from a pretrained model and applies a short recalibration phase. After this, the model preserves its original in-context performance while gaining strong zero-shot generalization to much longer sequences, outperforming RoPE scaling methods and alternative long-context architectures.

In training-from-scratch experiments (0.5B models on 16B tokens), the authors train a RoPE model normally for 14B tokens, then remove positional embeddings and continue training for the final 2B tokens as a short recalibration phase. This DroPE model matches the original RoPE model’s in-context perplexity while clearly outperforming NoPE and other long-context architectures (ALiBi, RNoPE-SWA) on long-context retrieval tasks from the RULER benchmark. Compared to RoPE scaling methods (PI, NTK-RoPE, YaRN), DroPE consistently achieves higher success rates at 2× the training context length.

They also apply DroPE to an already-pretrained 360M SmolLM model trained on 600B tokens, demonstrating that it can extend context in “models in the wild”. With recalibration budgets of 30–120B tokens (and adding QKNorm to stabilize training), DroPE effectively adapts pretrained LMs for long-context generalization without architectural changes.

DroPE scales effectively to billion-parameter models. When applied to SmolLM-1.7B and Llama2-7B, DroPE requires only ~20B tokens of recalibration (2% and 0.5% of their original training budgets). Even with this minimal additional training, DroPE consistently outperforms state-of-the-art RoPE scaling methods on long-context question answering and summarization, demonstrating that the approach remains effective at large scale and can be applied immediately to existing models.

Conclusions

DroPE stands out among other long-context methods by decoupling the benefits of positional embeddings during training from their drawbacks at inference. Compared to scaling or adapting existing positional schemes (like RoPE scaling methods), which still rely on retained or rescaled position information and often require further fine-tuning, DroPE requires no additional long-context training while preserving original model capabilities.

I like that DroPE exhibits efficient pretrained convergence and scalable inference. More than that, it yields zero-shot extension with only a minimal recalibration phase without ever needing to train on long-sequence data. This makes it a very computationally elegant and cost-effective context extension strategy.

Paper

Code

Project

The KIMI K2.5 represents a significant step forward for open-source multimodal AI by tackling two converging frontiers simultaneously: native text-vision integration and scalable agentic intelligence. Unlike many contemporary models that augment a predominantly text-based backbone with vision tokens late in training, K2.5 adopts joint pre-training and reinforcement learning across text and visual data — enabling both modalities to mutually strengthen one another rather than competing for capacity. This design choice, along with novel techniques like zero-vision supervised fine-tuning, positions the model as a unified multimodal system capable of complex perception and reasoning tasks.

Finally, K2.5 introduces Agent Swarm, a dynamic framework for parallel agent orchestration that yields up to ~4.5x reduction in inference latency and higher task performance compared to traditional sequential agent execution. It allows the model to dynamically decompose a prompt into a graph of heterogeneous sub-tasks, instantiate specialized agents for each, and execute them concurrently

Benchmark results show Kimi k2.5 achieving state-of-the-art (SOTA) performance in coding, math, and visual agentic tasks, outperforming comparable open-source models and rivaling proprietary giants like GPT-5.2 in specific high-reasoning domains.

Joint Optimization of Text and Vision

Kimi K2.5 is trained as a native multimodal model via large-scale joint pre-training on ~15T mixed text and vision tokens. Contrary to common practice, the authors show that aggressively injecting large amounts of vision data late in training is unnecessary. With a fixed token budget, early fusion with a moderate vision ratio performs better than late, vision-heavy training. This results in a novel design choice: integrate vision early and co-optimize both modalities throughout training to learn balanced multimodal representations.

To address the cold-start problem in multimodal reinforcement learning, the authors introduce zero-vision SFT. Instead of using scarce, hand-annotated vision SFT data, K2.5 uses high-quality text-only SFT, with visual operations proxied via programmatic operations in IPython. Experiments show that this is sufficient to activate visual and agentic behaviors, likely due to prior joint pre-training. And the usual text–vision SFT performs worse due to limited data quality.

Finally, K2.5 applies outcome-based visual RL on tasks that explicitly require vision (grounding, counting, charts, STEM problems). This improves visual reasoning and agentic behavior and also boosts text-only performance on benchmarks like MMLU-Pro, GPQA, and LongBench. At the post-training stage, the model is trained with joint multimodal RL, where experts are organized by ability (reasoning, coding, agentic skills) rather than modality. This paradigm maximizes cross-modal transfer, allowing improvements in vision to generalize to text and vice versa, without degrading language performance.

Agent Swarm

The authors argue that sequential agent execution is a fundamental bottleneck for complex, long-horizon tasks. As tasks grow wider (information gathering) and deeper (branching reasoning), a single agent quickly exhausts reasoning depth and tool-call budgets, making purely sequential systems poorly scalable.

To address this, Kimi K2.5 introduces Agent Swarm with Parallel Agent Reinforcement Learning (PARL). Instead of hard-coded parallelism or fixed heuristics, the model learns when and how to parallelize via RL. An orchestrator dynamically decomposes tasks, spawns heterogeneous subagents, and schedules them to run concurrently. Parallelism is not assumed to be beneficial by default; it emerges through reward-driven exploration based on task outcomes and efficiency.

PARL uses a decoupled architecture: a trainable orchestrator coordinates frozen subagents sampled from intermediate checkpoints. This avoids unstable end-to-end multi-agent training and sidesteps credit-assignment issues, treating subagent outputs as environmental observations rather than differentiable actions. Training starts with smaller subagents and progressively scales up, with dynamic resource allocation between the orchestrator and subagents.

The reward function combines task performance with two auxiliary terms: one encourages subagent instantiation (to avoid collapsing back to serial execution), and another rewards successful subtask completion (to prevent meaningless parallelism). These auxiliary rewards are annealed to zero over the course of training, ensuring the final policy optimizes task quality.

To explicitly optimize latency, the authors introduce critical steps, a metric similar to the critical path in parallel computation. Training and evaluation are constrained by critical steps rather than total steps, which incentivizes decompositions that reduce end-to-end execution time instead of merely increasing concurrency.

Finally, the orchestrator is trained on synthetic stress-test prompts designed to break sequential agents, emphasizing wide search, deep branching, and real-world workloads like long-document analysis. Without explicitly instructing parallelism, the task distribution naturally favors parallel execution, teaching the orchestrator to exploit Agent Swarm where it provides real benefit.

The general approach

Kimi K2.5 is built on Kimi K2, a trillion-parameter MoE language model trained on 15T text tokens, and extends it into a native multimodal, agentic system. Kimi K2 MoE LLM is combined with MoonViT-3D, a native-resolution vision encoder, connected via an MLP projector. MoonViT-3D unifies image and video understanding by sharing parameters and embedding space across both modalities, treating short video clips as spatiotemporal “patch-and-pack” sequences. This helps to avoid specialized video modules while enabling efficient long-video processing through lightweight temporal pooling and compression.

Pre-training proceeds in three stages over ~15T additional multimodal tokens:

• standalone ViT training to build a strong visual encoder from image–text and video–text data;
• joint text–vision pre-training starting from a near-final Kimi K2 checkpoint to co-optimize language and multimodal capabilities;
• mid-training with higher-quality data and long-context activation, progressively extending context length via YaRN interpolation.

Post-training follows large-scale SFT + RL. Supervised fine-tuning uses synthesized high-quality responses from multiple Kimi variants and expert models, emphasizing reasoning depth and tool use. Reinforcement learning is unified across text, vision, and agentic behaviors using a shared agentic RL environment. The policy optimization uses token-level clipping to stabilize off-policy RL in long-horizon, tool-using settings, paired with outcome-based and GRM-based rewards. Visual tasks use task-specific reward formulations (IoU, edit distance, counting error, etc), while Generative Reward Models provide fine-grained preference signals across diverse agent types.

Evaluations

Kimi K2.5 delivers frontier-level performance across reasoning, coding, agentic, and multimodal benchmarks, often matching or surpassing leading proprietary models. It shows strong STEM and scientific reasoning (AIME, HMMT, MMLU-Pro, GPQA), clear gains from tool use on HLE, and competitive real-world software engineering performance (SWE-Bench, LiveCodeBench, CyberGym).

The Agent Swarm delivers large gains beyond the base model: multi-agent orchestration consistently improves performance over single-agent K2.5 and often surpasses GPT-5.2 Pro. These gains are paired with latency reductions: parallel execution yields 3–4.5x wall-clock speedups, with execution time remaining nearly constant as task difficulty increases.

Additionally, Agent Swarm functions as proactive context management: tasks are decomposed into parallel, semantically isolated subtasks handled by specialized subagents with bounded local context. Only distilled results are returned to the orchestrator, enabling context sharding rather than context truncation. This allows K2.5 to scale to long-horizon, high-complexity tasks while preserving reasoning integrity and modularity.

Conclusions

Kimi k2.5 positions itself as a strong open-source competitor in the agentic domain, directly challenging GPT-5.2 and Claude Opus 4.5. Kimi k2.5 differentiates itself from other models thanks to its native visual capabilities.

I really like the Agent Swarm orchestration introduced here. Most current models rely on long, linear contexts that degrade in speed as complexity increases. Kimi k2.5 breaks this “linear curse” by parallelizing the reasoning process. The fact that Anthropic already implemented this functionality shows that it was a great idea.

Paper

Code

Project

PaperBanana is an agentic framework for automatically generating publication-ready academic illustrations. It coordinates specialized agents to retrieve references, plan content and style, render images, and iteratively refine results via self-critique using VLMs and image generation models. To evaluate the approach, the authors introduce PaperBananaBench, a benchmark of 292 methodology-diagram tasks curated from NeurIPS 2025 papers. Experiments show that PaperBanana outperforms strong baselines in faithfulness, conciseness, readability, and aesthetics, and the framework generalizes to high-quality statistical plot generation.

Task Formulation

The authors formulate automated academic illustration generation as the task of learning a function that maps a source context and communicative intent to a visual output. Given context and intent, the goal is to generate an image that faithfully represents the content while matching the intended focus. The formulation can be extended with optional reference examples, enabling few-shot guidance; without them, the task reduces to zero-shot generation. This paper focuses primarily on methodology diagrams, where the context is the textual method description and the intent is the figure caption that defines the illustration’s scope.

Methodology

PaperBanana coordinates five specialized agents - Retriever, Planner, Stylist, Visualizer, and Critic - to transform scientific text into publication-quality diagrams and plots.

The Retriever selects relevant reference examples using VLM-based reasoning, prioritizing diagram structure and type over topical similarity. The Planner acts as the system’s cognitive core, converting the source context and communicative intent, guided by references, into a detailed textual plan of the target illustration. The Stylist enforces academic visual standards by synthesizing an aesthetic guideline from the reference corpus and refining the plan accordingly. The Visualizer generates images from the refined description using an image generation model, while the Critic evaluates each output against the original intent and context, providing feedback for iterative refinement. This Visualizer–Critic loop runs for three iterations to ensure accuracy, clarity, and visual quality.

The framework extends to statistical plot generation by having the Visualizer produce executable Matplotlib code instead of images, with the Critic iteratively correcting errors or inconsistencies.

Benchmark

Data Curation

The authors sample 2k NeurIPS 2025 papers, parse PDFs with MinerU to extract methodology text, diagrams, and captions, and filter for quality. Papers without methodology diagrams are removed, and diagrams are further filtered by aspect ratio to ensure suitability for generation and fair evaluation, yielding 610 candidates. Diagrams are then categorized into four types: Agent & Reasoning, Vision & Perception, Generative & Learning, and Science & Applications. A final human curation step verifies text, captions, and categories and removes low-quality visuals, resulting in 584 high-quality samples, split evenly into a test set and a reference set.

Evaluation Protocol

The authors evaluate generated diagrams and plots using a VLM-as-a-Judge with a referenced comparison setup, where model outputs are directly compared against human-drawn figures. Evaluation covers two perspectives:

• Content: faithfulness to the source and communicative intent, and conciseness
• Presentation: readability and aesthetics

For each dimension, the judge assigns a win, loss, or tie relative to the human reference, mapped to scores of 100, 0, and 50. Overall scores are computed via a hierarchical aggregation that prioritizes faithfulness and readability over conciseness and aesthetics, ensuring that correctness and clarity dominate visual appeal.

Experiments

PaperBanana outperforms other models but underperforms the human reference in terms of faithfulness.

• Removing the Retriever results in substantial declines in conciseness, readability, and aesthetics, as the system produces verbose, visually unrefined diagrams. Surprisingly, using randomly selected references performs comparably to semantic retrieval, indicating that exposure to general structural and stylistic patterns matters more than precise content matching.
• The Stylist agent improves conciseness and aesthetics but slightly harms faithfulness by omitting technical details, while the Critic agent compensates for this loss by restoring faithfulness through iterative refinement. Additional refinement iterations further improve all metrics, balancing visual quality and technical accuracy.

Limitations and Future Directions

The authors discuss the limitations of PaperBanana and outline future directions.

• A key limitation is that the framework produces raster images, which are difficult to edit compared to vector graphics; potential solutions range from post-hoc image editing to reconstructing vector representations to agents that directly operate professional design software.
• Another challenge is the trade-off between standardized academic style and stylistic diversity, as a unified style guide constrains variation.
• While PaperBanana performs well visually, it still lags humans in fine-grained faithfulness, particularly in subtle structural details like arrow directions, reflecting limits of current VLM perception.

Possible extensions include test-time scaling to generate multiple stylistic variants for user or model selection, and applying the reference-driven paradigm to broader domains such as UI/UX design, patents, and industrial schematics.

Paper

Hyper-Connections (HC) architectures expand residual streams and diversify connectivity patterns beyond traditional residual blocks but break the identity mapping property, causing training instability, poor scalability, and inefficient memory access. The authors propose Manifold-Constrained Hyper-Connections (mHC), a general framework that projects HC residual connections onto a defined manifold to restore identity mapping while retaining the expressivity of HC. The design incorporates infrastructure-level optimizations to keep memory and computational costs low.

Empirical evaluation shows that mHC trains robustly at scale, improves performance across tasks, and scales better than prior HC variants without sacrificing efficiency.

Introduction

Residual connections are widely used in modern deep networks because their identity mapping property lets signals pass unchanged across layers, stabilizing training at scale. Hyper-Connections extend this idea by widening the residual stream into multiple parallel channels and learning how to mix them, increasing expressivity and topological complexity without raising per-layer FLOPs. However, this unconstrained mixing breaks the identity mapping property: across many layers, the residual transformations no longer preserve the global mean of the signal, leading to amplification or attenuation and training instability. In addition, the widened residual stream introduces significant memory-access overhead. As a result, despite their performance potential, Hyper-Connections are unstable and hard to scale in large training regimes.

The approach

Manifold-Constrained Hyper-Connections

mHC restores stable signal propagation by constraining the residual mixing matrix onto a specific manifold rather than leaving it unconstrained as in Hyper-Connections. Instead of forcing the residual mapping to be the identity, which would block interaction between streams, it is restricted to be a doubly stochastic matrix, with non-negative entries and rows and columns summing to one. This preserves the identity mapping behavior in a generalized form while still allowing information exchange across streams.

Doubly stochastic matrices are non-expansive, which limits gradient explosion, and they are closed under multiplication, so stability is preserved across many layers. Geometrically, they form the Birkhoff polytope, meaning each residual mapping acts as a convex combination of permutations and gradually increases mixing across streams, functioning as robust feature fusion. Additional non-negativity constraints on the input and output projection matrices prevent signal cancellation and further stabilize training.

Parameterization and Manifold Projection

At each layer, the hidden state is flattened into a single vector and passed through RMSNorm to generate dynamic mixing weights, following the original Hyper-Connections setup. Linear projections produce unconstrained versions of the input mapping, output mapping, and residual mixing matrix. The input and output mappings are then passed through a sigmoid to enforce non-negativity, while the residual mixing matrix is projected onto the manifold of doubly stochastic matrices using the Sinkhorn–Knopp algorithm. This projection exponentiates the matrix to make all entries positive and then iteratively normalizes rows and columns to sum to one, converging to a doubly stochastic matrix after a fixed number of steps. In practice, about 20 normalization iterations are used to obtain the final constrained residual mapping.

Efficient Infrastructure Design

To reduce mHC overhead, the authors reorder the normalization step to follow matrix multiplication. This preserves mathematical equivalence while lowering latency on high-dimensional inputs. They use mixed-precision to balance numerical accuracy and speed, and fuse operations with shared memory access into unified compute kernels to alleviate memory bandwidth bottlenecks. Three specialized kernels compute the input mapping, output mapping, and residual mixing matrix, with biases, projections, and RMSNorm weights absorbed into consolidated parameters. Additional fusion combines multiple scans, lightweight coefficient operations, and the Sinkhorn–Knopp iteration into single kernels. The custom backward pass recomputes intermediate results on-chip. Two further kernels apply the mappings, with residual merging fused to drastically cut memory reads and writes. Most kernels are implemented with TileLang, enabling efficient handling of complex computations while maximizing memory bandwidth utilization with minimal engineering overhead.

The n-stream residual design greatly increases memory usage, so mHC drops all intermediate activations after the forward pass and recomputes them during backpropagation by rerunning the mHC kernels without the expensive layer function. For each block of consecutive layers, training stores only the input to the first layer, which reduces resident memory.

Pipeline parallelism with the DualPipe schedule overlaps communication and computation, but the n-stream residual design in mHC adds significant cross-stage communication latency and extra recomputation cost at stage boundaries. To reduce these bottlenecks, the authors extend the schedule to improve overlap between communication and computation when entering new pipeline stages. The kernels in MLP layers run on a dedicated high-priority compute stream to avoid blocking communication, while long persistent kernels in attention layers are avoided to prevent stalls and allow preemption.

Experiments

mHC effectively mitigates the training instability observed in HC and yields comprehensive improvements on the downstream benchmarks.

The performance advantage is robustly maintained even at higher computational budgets, which proves the effectiveness of mHC in large-scale scenarios.

mHC maintains much more stable signal and gradient propagation than Hyper-Connections.

You can read my review on DeepSeek-R1 here.

This year, I wrote 30+ paper reviews. That was not a planned goal - it just happened while I was reading really interesting papers. A lot of research, unsurprisingly, went into LLMs: reasoning, training recipes, evaluation, and scaling laws. But not everything interesting this year was an LLM. There were strong papers on vision, agents, time series, evaluation benchmarks, and even re-thinking how we train “old” models like BERT.

I want to highlight ten papers that I was personally interested in — papers that introduced a particularly exciting idea, or simply felt like a glimpse into where the field is going next. This is a subjective list. It reflects my interests, my biases, and the kinds of questions I keep asking myself as an ML engineer.

I don’t include top LLMs, as their papers are usually technical reports with minimal detail.

DeepSeek-R1: Reasoning Without the Usual Crutches

DeepSeek-R1 is one of the most interesting reasoning papers of the year because it challenged an assumption many had already accepted: that strong reasoning requires heavyweight tricks like supervised chain-of-thought or expensive human-annotated reasoning traces. It offered pure reinforcement learning instead. The model is pushed to reason better without being explicitly shown how to reason. This demonstrated that reasoning can emerge as a behavior, not just as imitation. This paper started a shift to investing more in RL and reward design for LLMs.

And, yes, it was published this year. Not an eternity ago - less than 12 months back.

GSPO: New Policy Optimization for LLMs

GSPO (Group Sequence Policy Optimization) was used in Qwen3 and contributed “remarkable improvements” to it. It used sequence-level importance ratios instead of token-level, provided more stable training, and simplified the design of RL infrastructure. It removed the need for a separate critic model by using group-based relative rewards, which further reduces the hardware requirements for training cutting-edge AI. What makes GSPO interesting is that it aligns the optimization objective with how we actually evaluate language models, reducing a class of failure modes that many pipelines quietly struggle with today.

Lumine: Generalist Agents in Open 3D Worlds

I didn’t write a review on Lumine, but this is a fascinating research. The paper presents an open recipe for training agents that can act, explore, and generalize in large 3D environments - open-ended worlds. The emphasis is on generalist behavior: navigation, interaction, adaptation. It blew my mind that this agent can play Genshin Impact and other games with reasonable efficiency.

SAM-3: Segment Anything Grows Up

SAM-3 continues the evolution of the Segment Anything line and reflects a deeper understanding of what segmentation models are actually used for in real systems. The main impact is the transition from class-agnostic segmentation to semantically-aware segmentation. And users can prompt it not just with simple points, boxes, or nouns, but also with complex semantic concepts.

Chronos-2: Time Series Without task-specific training

Chronos-2 treats time series forecasting as a sequence modeling problem, it builds on foundation-model ideas and shows that with the right training setup, you can get strong performance across diverse time series tasks without hand-crafted features or manual seasonality modeling. Chronos-2 suggests that we can have universal zero-shot time series forecasting.

NeoBERT: Modernizing BERT

NeoBERT raised an interesting question: what if we trained BERT properly, using everything we’ve learned up to now? The paper revisits BERT with modern training techniques — better tokenization, better objectives, better optimization — and shows that you can still squeeze meaningful gains from it. What’s more interesting, it gets high scores on the MTEB benchmark, showing that its embeddings can rival modern models.

AlphaEvolve: Search Meets Learning

AlphaEvolve explores the space between evolutionary algorithms and modern learning systems. It shows how structured evolution can guide discovery in complex optimization spaces: it proposes solutions, evaluates them objectively and iteratively refines them.

SWE-rebench: Scalable and continuously updated benchmark

Instead of synthetic tasks or cherry-picked prompts, SWE-rebench evaluates models on real software engineering problems: fixing bugs in real repositories, under realistic constraints. The result is a benchmark that exposes just how brittle some “coding-capable” models still are.

DINOv3: Self-Supervised Vision Keeps Scaling

The paper refines the DINO approach with better training recipes and larger models, producing representations that transfer well across tasks without supervision. What stands out is how general these representations are: they feel less like features and more like visual understanding.

Dragon Hatchling: Small Models, Real Capabilities

Dragon Hatchling focuses on small models that punch above their weight. Instead of assuming scale solves everything, the paper explores how careful training, curriculum design, and architectural choices can produce compact models with surprisingly strong reasoning and generalization abilities. Dragon Hatchling is a biologically inspired LLM built as a scale-free graph of locally interacting neuron-like units.

Closing Thoughts

This was an interesting year for ML research. We saw noticeable progress in LLMs, vision models, agents, and time series. There were many incremental improvements, but also some breakthroughs. LLMs dominate the research, but there are other interesting papers that combine different things: learning and search, vision and language, agents and environments.

This year was again about showing what foundation models can do, maybe the next one will be about figuring out how to make them reliable, grounded, and genuinely useful.