Introduction
I missed the last two weeks due to traveling and other activities, therefore this newsletter combines interesting news, releases and papers from the last two weeks. There was Apple's Worldwide Developer Conference, which brought two notable announcements for me: developers will have access to Apple's Foundation Model stored on each device for app development, the 2026 iPhone 18 Pro will get the next-generation A20 chip [1] (big step for mobile AI) and Apple has changed its naming convention to a common sense one by using the release years as suffixes (like iOS26).
Significant model releases in the last two weeks were o3-pro, which is the new flagship reasoning model from OpenAI as well as Magistral from Mistral, which is a powerful open-weights reasoning model. ByteDance released with Seedance 1.0 a Veo3 competitor. Personally, even though not a model release, I was also delighted that Claude Code was added to Pro Subscriptions. The Usage Limit is still maxed out quite fast but I enjoy not eyeing on the Billing board every 5-10 mins.
The famous “Attention is all you Need” title from the Transformer paper was also reformulated to express what is most important at the moment to “Context is all you Need”. Developments like MCP and A2A prove that most effort in the Application Layer of LLM apps is directed to giving the models the necessary context. In line with that, I also discuss in this newsletter two blog posts regarding how to build Multi-Agentic systems, where both emphasize the importance of close coordination with careful provisioning of as much context as possible to all agents.
Also, a naming convention has developed, where all the new models that are able to think are called Large Reasoning Models (LRMs), which outperform the “basic” Large Language Models (LLMs) in most tasks at the moment. The multimodal models are called Vision Language Models (VLMs).
My paper selection of the last weeks is mostly concerned with these LRMs. The most discussed paper is the Illusion of Thinking paper from Apple. It basically tested LLMs to LRMs in complexity-controllable puzzle environments and found that LLMs are more efficient for easier levels, LRMs are better for medium levels and both collapse completely after a certain complexity level, indicating that the LRMs are not able to use reasoning from the medium level solutions to the higher levels, which they should when they are actually reasoning. Another paper examined LRMs through token entropy patterns, measuring the certainty for each token in generated sequences. The researchers discovered that a model's reasoning potential correlates with high-entropy "forking tokens"—words like "but" or "however" that create reasoning branches and low-entropy tokens in a certain ratio of 80/20, low/high. The last two papers I selected examine how much information a typical Transformer memorizes per parameter, which is 3.6 bit and the other uses autoregressive Transformers to label their own data, reaching production-level quality.
Releases
o3-pro
o3-pro represents OpenAI's most advanced reasoning model, utilizing reinforcement learning to generate step-by-step solutions through a "private chain of thought" process. The model significantly outperforms its predecessor o1, achieving remarkable benchmarks including 87.7% on GPQA Diamond (expert-level science questions) and demonstrating superior performance across complex mathematical and coding challenges.
What distinguishes o3-pro is its enhanced reasoning capabilities through extended deliberation time, allowing it to analyze problems more thoroughly before responding. The model can "think with images," processing visual content during its reasoning phase, and has access to comprehensive tools including web browsing, Python code execution, and file analysis However, this enhanced reasoning comes with longer response times, with OpenAI recommending it for "challenging questions where reliability matters more than speed, and waiting a few minutes is worth the tradeoff". The model is priced at $20 per million input tokens and $80 per million output tokens in the API, with additional discounts for cached content. It's available to ChatGPT Pro and Team users, replacing the previous o1-pro.
Seedance 1.0
Seedance 1.0 is ByteDance's flagship video generation model, ranking first on both text-to-video and image-to-video leaderboards on Artificial Analysis while significantly outperforming competitors like Google's Veo 3.
The model's technical architecture represents a breakthrough in unified video generation, supporting bothtext-to-video and image-to-video tasks within a single framework. Seedance 1.0 achieves exceptional inference speed, generating 5-second 1080p videos in just 41.4 seconds on NVIDIA-L20 hardware through ~10x speedup via multi-stage distillation strategies and system-level optimizations. The model employs an efficient architecture with decoupled spatial and temporal layers, interleaved multimodal positional encoding, and comprehensive video-specific RLHF training. Unlike competitors that typically excel in only one domain, Seedance 1.0 offers superior motion quality, multi-shot storytelling capabilities, and maintains consistency across shot transitions.
The model supports diverse styles from photorealism to cyberpunk aesthetics, while accurately parsing complex natural language prompts for multi-agent interactions and sophisticated camera movements. While Veo 3 excels in prompt-following capability, Seedance 1.0 surpasses it in motion quality, avoiding common issues like oily appearance or blurred details that constrain complex video synthesis
Magistral
Mistral's new reasoning model modifies DeepSeek's RL training pipeline with several key improvements across four dimensions:
Algorithmic Changes to GRPO:
Eliminated KL divergence term (policy drifts anyway, saves compute by not storing reference weights)
Added loss normalization by generation length
Implemented advantage normalization
Relaxed trust region upper bound clipping
Enhanced Rewards:
Built on DeepSeek's format/correctness rewards
Added length penalty with gradually increasing max length
Introduced language consistency reward (+0.1 for coherent problem-thoughts-answer triples via fastText classifier)
Infrastructure Challenges:
RL fundamentally changes LLM training infrastructure
Key issues: avoiding idle time across generators/verifiers/trainers and maintaining on-policy learning
Compute now distributed across inference servers generating response groups
Data Improvements:
Filter out "non-diverse groups" (all correct/incorrect responses with zero advantage)
Sort problems by difficulty using 2-stage pipeline
Implement curriculum learning (simple to hard progression)
Key Insights:
Small models do benefit from RL (contradicts some prior work)
SFT cold start + RL gives best results
Free performance gains on multimodal/tool calling despite no RL training on that data
Partial rewards for code hurt performance (rewarding 20% test case passes degrades results)
The focus has shifted from architecture tweaks to efficient infrastructure, reward shaping, and data curation.
Papers
The Illusion of Thinking [5]
The paper "The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models" investigates Large Reasoning Models (LRMs) like OpenAI's o1/o3, DeepSeek-R1, and Claude 3.7 Sonnet Thinking, which generate detailed "thinking processes" (Chain-of-Thought) before providing answers.
Instead of traditional mathematical and coding benchmarks, which can suffer from data contamination and don't reveal internal reasoning quality, the authors use controllable puzzle environments (e.g., Tower of Hanoi, River Crossing). These puzzles allow for precise manipulation of problem complexity and detailed analysis of reasoning traces.
Main insights are:
Performance Collapse: LRMs experience a complete accuracy collapse beyond certain complexity thresholds, similar to their non-thinking counterparts, merely delaying it.
Counterintuitive Scaling Limit of Reasoning Effort: LRMs demonstrate a surprising decline in reasoning effort (measured by inference-time tokens) as problem complexity increases, even when they have ample token budgets. This suggests a fundamental scaling limitation in their thinking capabilities relative to problem complexity.
Three Regimes of Complexity:
For low-complexity tasks, standard LLMs surprisingly outperform LRMs in accuracy and token efficiency, potentially due to memorization.
In medium-complexity tasks, LRMs show an advantage by generating long chains-of-thought.
For high-complexity tasks, both LRMs and standard LLMs experience complete performance collapse.
Inefficiencies in Reasoning Traces: Analysis of intermediate "thoughts" reveals that for simpler problems, LRMs often find the correct solution early but then inefficiently explore incorrect alternatives ("overthinking"). For higher complexity, models fail to generate any correct solutions, indicating limited self-correction.
Limitations in Exact Computation: LRMs show surprising inabilities in performing exact computation. Even when provided with explicit solution algorithms (e.g., for Tower of Hanoi), their performance does not improve, and the collapse occurs at similar points. This suggests limitations not just in discovering problem-solving strategies but also in consistent logical verification and step execution. Moreover, models can perform many correct moves in one puzzle but fail very early in another, potentially due to scarce training examples for specific puzzle types on the web.
In essence, the paper challenges assumptions about LRM capabilities, indicating that current approaches might be encountering inherent compute scaling limits and inefficiencies, rather than developing truly generalizable reasoning.
Beyond the 80/20 Rule [7]
The authors investigated token entropy patterns and how they are affected by Reinforcement Learning with Verifiable Rewards (RLVR). High-entropy tokens are critical decision points where multiple paths are viable (like "however," "unless"), while low-entropy tokens are predictable completions (like word endings, math expressions). The paper shows that only ~20% of tokens (the high-entropy "forking tokens") drive nearly all reasoning performance gains during reinforcement learning with verifiable rewards (RLVR), while the remaining 80% contribute little.
The authors discovered that in LLM chain-of-thought reasoning:
50%+ of tokens have near-zero entropy (~deterministic completions)
Only 20% have high entropy - these act as "forks" steering reasoning paths
During RLVR training:
The model largely preserves the base model's entropy patterns
RLVR primarily adjusts high-entropy tokens while low-entropy tokens remain stable
Training on only the top 20% highest-entropy tokens matches or exceeds full-gradient performance
Training on the bottom 80% low-entropy tokens caused severe performance degradation.
The 20% high-entropy tokens enhance exploration during RL by maintaining reasoning path flexibility. This explains why RL generalizes while supervised fine-tuning memorizes - SFT reduces entropy at critical decision points, losing flexibility.
The findings suggest RLVR's effectiveness comes from optimizing a small subset of tokens that govern reasoning directions, not from uniform updates across all tokens.
Unsupervised Elicitation of Language Models [9]
This paper shows that a sufficiently pretrained model can generate its own labelled finetuning dataset and can even outperform production-grade LLMs.
Human Labelling is still considered the gold standard (labeling by subject matter experts (SME) is also called golden supervision) but it is not perfect and can be replaced in some areas by the models themselves. Thats the basic theme of the paper:
Before: "We need humans to teach AI what's right"
After:"AI already knows what's right, we just need better ways to elicit (aka “bring it out”) it"
They authors did this with an algorithm called Internal Coherence Maximization (ICM). The algorithm essentially is:
Give the model a set of questions with candidate answers
The model labels the Q-A pairs with True or False, returning multiple sets of labelled pairs
The model revisits each set of pairs and returns the overall probability (mutual predictability score) of the set, when each datapoints is “mutually predicting” all the other ones, meaning having a high probability of predicting their labels.
Then the model is evaluating the labelled Q-A pairs on logical consistency by basic rules like
Same question can't have contradictory answers
A can't be both better and worse than B
and returning a score
Score from 3 and 5 are combined into one overall score
Optimizes the overall score over all sets of Q-A pairs to achieve “maximum internal coherence”.
The authors trained a reward model on the labelled data and ran reinforcement learning that returned a model beat the human-supervised version of Claude-3.5 Haiku in head-to-head comparison.
The ICM algorithm struggles when used for topics that are not very present in the Pretraining and when used for long Q-A pairs because in order to calculate the mutual predictability score entropy of a whole set, you need to put all the pairs of a set in the (effective) context window of a model.
How do Language Models memorize? [6]
This paper introduces a new method to measure exactly how many bits of information a model "knows" about its training data, finding that GPT-style models can store approximately 3.6 bits per parameter.
Memorization components: The paper formally separates memorization into unintended memorization (information about specific training samples) and generalization (information about the true data distribution).
The authors measure model capacity using synthetic random bitstrings where generalization is impossible:
GPT models store ~3.6 bits per parameter (3.51 in bfloat16, 3.83 in fp32)
Models memorize training data until reaching capacity, then plateau regardless of dataset size
Doubling precision only marginally increases capacity, suggesting most extra bits go unused
The Memorization-Generalization Tradeoff
When training on real text:
Models initially memorize individual samples
Once capacity fills, "grokking" occurs - models replace sample-specific memorization with generalizable patterns
Double descent happens exactly when dataset size exceeds model capacity
This provides an intuitive explanation: when models can no longer memorize individually, they're forced to share information between datapoints, leading to generalization.
The paper derives scaling laws showing membership inference follows a sigmoidal curve based on the capacity-to-dataset ratio:
Easy when models overfit small datasets (F1 → 1.0)
Becomes random guessing as datasets grow large (F1 → 0.5)
Modern LLMs trained with 100+ tokens per parameter make membership inference statistically impossible
The practical implications are
Model capacity is fundamental - not just a function of parameters but architecture and precision
Extraction ≠ memorization - models can generate text they haven't memorized through generalization
Rare tokens are memorized most - samples with high TF-IDF scores (rare words) consume more capacity
The framework provides a principled way to understand when models memorize vs. generalize, with implications for privacy, training efficiency, and model design.
Blogs/Practical Insights
Fine-Tuning LLMs is a Huge Waste of Time [10]
I liked this post from the Artifical Intelligence Made Simple Newsletter, because finetuning is often talked about as a viable option to update a model with new information or to customize the model. But finetuning all layers of a previously trained model is not a knowledge injection but a knowledge overwrite [10]. Better solutions are using a RAG to retrieve all relevant information at inference time or to spend more time in prompt engineering. Both methods don’t change the parameters of the models. If both of these are not sufficient, try training a small subset of the parameters (0.1 %) with LoRA or try to use a modular setup with more than one model to solve your use case.
Things to consider when building multi-agent systems [11,12]
There were two recent blog posts, one from Anthropic [11] and one from Cognition [12] (the company that develops the AI Software Engineer Devin), which argued for completely opposite directions when developing Multi-Agent Systems. Both can be summarized as follows:
When you want to divide a big task into smaller subtasks with one agent per subtask, make sure to design the system so that the agents have clear task definition as well as boundaries and that they share as much context as possible (Cognition even trained a model to compress context, so that each agent can be provided with it). Even though Anthropic spawns Agents in parallel, the vast majority should use sequential systems because they are much easier to setup and monitor.
References
[1] A20 chip: https://9to5mac.com/2025/06/03/apples-a20-chip-packaging-breakthrough/?utm_source=tldrnewsletter
[5] The Illusion of Thinking: https://www.arxiv.org/abs/2506.06941
[6] How do Language Models memorize: https://arxiv.org/abs/2505.24832
[7] Beyond the 80/20 rule: https://arxiv.org/abs/2506.01939
[8] Seedance 1.0 https://arxiv.org/html/2506.09113v1
[9] Unsupervised Elicitation of Language Models: https://arxiv.org/pdf/2506.10139
[10] Finetuning is a huge waste of time
[11] How we built our Mulit-Agent Research system: https://www.anthropic.com/engineering/built-multi-agent-research-system
[12] Don’t built multi-agent systems: https://cognition.ai/blog/dont-build-multi-agents