Benchmarks and evaluation design
ARC-AGI, long-horizon and interactive tests, cost-aware scoring, contamination controls, and comparisons that isolate model capability from tooling.
36%
Best tweets about AI Reasoning Models
50 Best Tweets About AI Reasoning Models (2026)
Explore the best tweets about AI reasoning models, from test-time compute and benchmarks to problem solving, evaluation, limitations, and model research.
Reasoning-model research, test-time compute, evaluations, benchmarks, failure modes, costs, and evidence of improved problem solving.
- Creators
- 41
- Updated
Original Xholic analysis
What 50 top AI Reasoning Models posts reveal
The conversation pairs enthusiasm for reasoning-model research with demands for harder evaluations and cost-aware comparisons. Posts report gains from training, structured agents and latent computation, alongside brittle debugging, overthinking and incomplete reasoning traces. A recurring question is when additional computation improves reliable problem solving enough to justify its cost.
- Dominant tone
- Positive
- Median score
- 20.2
- Leading format
- Announcement
- Recent posts
- 20%
46% of posts
All-time engagement
90% of posts
Published in 90 days
Conversation map
The themes creators return to
Test-time compute and effort
Sampling, verification, adaptive reasoning budgets, and the gains or diminishing returns from thinking longer.
34%
Training reasoning models
Reinforcement learning, verifiable rewards, synthetic solution data, self-distillation, and what reasoning training actually changes.
30%
Reasoning efficiency and cost
Thinking-token bills, misleading API prices, model-size tradeoffs, context compression, attention efficiency, and latency.
28%
Agentic and collective reasoning
Planning-and-reflection loops, shared-workspace agents, internal debates, and scaffolds for sustained problem solving.
20%
Reasoning failure modes
Brittle code understanding, surface-heuristic shortcuts, weak step composition, irrelevant-context copying, and errors caused by overthinking.
18%
Reasoning traces, calibration, and safety
Whether chain-of-thought faithfully reveals decisions, how to monitor hidden reasoning or reward hacking, and how models assess their own uncertainty.
16%
Latent and nonverbal reasoning
Abstract tokens, recursive hidden-state computation, and action-aligned representations as alternatives to written chain-of-thought.
12%
Tone and stance
SentimentPositive leads
Author postureSupportive leads
Performance benchmark
- Median likes
- 82
- Median reposts
- 12
- Median replies
- 7
- Median views
- 7.4K
Posts with media make up 86% of this collection. Their median all-time score is 21.9, compared with 8.83 for text-only posts.
Format mix
- Announcement90% · score 23.8
- Opinion10% · score 2.74
Consensus and debate
Where creators agree, and where they do not
Shared view
Evaluation must separate capability from scaffolding
Benchmark posts emphasize interactive tasks and testing models without human-crafted state management. The vintage-model post also acknowledges modern-model involvement in fine-tuning as a contamination risk, qualifying its reasoning claims.
Shared view
Measure actual cost, not token prices alone
Cost-audit posts warn that listed API prices can misrank models once thinking-token usage is included. Other posts call for spend-matched comparisons and runtime effort policies that measure accuracy, latency and cost together.
Shared view
Reasoning structure matters alongside compute
Posts report gains from explicit planning-and-reflection loops, shared-workspace agents and action-aligned latent reasoning. These describe distinct approaches to improved problem solving rather than treating longer written traces as the sole mechanism.
Open debate
How far can test-time scaling go?
One post argues capability plateaus may lie beyond practical compute budgets. Others report length-composition failures that additional inference compute does not rescue, or quantized models that reach correct answers and then overthink. These concern different settings, not a settled universal scaling rule.
Open debate
Does demonstrated success establish robust reasoning?
The vintage-model post interprets few-shot Python generation as genuine reasoning. Debugging and constraint-following posts instead report sensitivity to superficial changes and keyword shortcuts. These contrasting interpretations illustrate different standards for convincing evidence of reasoning, rather than a direct comparison on the same task.
Open debate
Reasoning traces: useful defense or unreliable witness?
OpenAI describes chain-of-thought monitoring as a defense worth preserving. Other posts highlight reward hacking not disclosed in traces and consequential latent computation absent from readable output. These raise questions about monitoring's sufficiency without establishing that traces contain no useful information.
What performs
Patterns behind standout posts
Training research leads theme-level scores
Training reasoning models has the highest supplied theme median all-time score, at 30.548, versus 24.73 for benchmarks and evaluation design and 9.908 for test-time compute and effort. The RL-methods overview is the leading supplied outlier: 1140.85, or 56.37 times the overall median.
Announcements outperform opinions in this set
Announcements account for 45 posts (90%) and have a median all-time score of 23.807; opinions account for 5 (10%) with a median of 2.736. This is a descriptive format difference, not evidence that announcement framing causes stronger performance.
Failure and safety posts also break through
High-scoring outliers are not exclusively celebratory: the debugging critique scores 497.36, or 24.57 times the median, while OpenAI's monitorability disclosure scores 313.74, or 15.5 times the median. Both prominently discuss limitations.
Statistical standouts
- View standout post 1Score 1140.8 · 56.37× median
- View standout post 2Score 1061.5 · 52.45× median
- View standout post 3Score 598.2 · 29.56× median
- View standout post 4Score 497.4 · 24.57× median
- View standout post 5Score 313.7 · 15.5× median
Creator landscape
Who shapes this conversation
The five most represented creators account for 20% of the selected posts.
1. Alex Veremeyenko
@alex_verem
2 posts
2. Artificial Analysis
@ArtificialAnlys
2 posts
3. BURKOV
@burkov
2 posts
4. Marco Pavone
@drmapavone
2 posts
5. Guri Singh
@heygurisingh
2 posts
6. Om Patel
@om_patel5
2 posts
Leading repeat voices span optimism and cost scrutiny
Among the supplied top voices, Om Patel has 2 posts and a median all-time score of 539.64; Alex Veremeyenko has 2 and a median of 309.05. Patel covers vintage-model reasoning and Pokémon progress; Veremeyenko covers agent architecture and pricing reversals.
Artificial Analysis supplies qualified comparisons
Artificial Analysis has 2 posts with a median all-time score of 28.29. Its comparisons distinguish overall intelligence from agentic strengths, hallucination behavior and token efficiency, including a non-reasoning model competitive with reasoning peers.
Since the previous snapshot
What changed since Aug 26, 2026
- 68% of the selected posts remained.
- The creator count changed by 0.
- The leading sentiment remained stable.
How this analysis was made
Themes, sentiment, stance, and post format are classified per tweet. All counts, shares, medians, creator concentration, freshness, and performance comparisons are then calculated directly from the published snapshot.
Xholic's all-time score compares engagement while accounting for reach, post age, and creator consistency. It is used for relative comparisons within this collection.
This report analyzes the exact 50-post snapshot shown below. AI identifies editorial categories and drafts explanations; all statistics are calculated from the snapshot, and every narrative claim is checked against cited posts before publication.
Best AI Reasoning Models tweets
Top AI Reasoning Models tweets from 41 creators
Ranked 01–50
- 01
@a_weers ·
Finally finished! If you're interested in an overview of recent methods in reinforcement learning for reasoning LLMs, check out this blog post: https://t.co/SHUyFF4rvP It summarizes ten methods, tries to highlight differences and trends, and has a collection of open problems
- 21Replies
- 242Reposts
- 1.8KLikes
- 318.2KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 02
@om_patel5 ·
RESEARCHERS JUST BUILT AN AI MODEL TRAINED ONLY ON TEXT FROM BEFORE 1931 it's called talkie. 13 billion parameters, trained exclusively on text published before december 31, 1930 its worldview is completely frozen in time the reason this matters: every major AI model today (GPT, claude, gemini, llama) was trained on the modern web. that makes it almost impossible to tell if these models actually reason or if they just memorized the answers from their training data talkie breaks that completely because it has never seen any modern information the crazy part: talkie can learn to write python code from just a few examples you show it in the prompt. despite having ZERO modern code in its training data. it's figuring out programming from 19th century mathematics texts. that's ACTUAL reasoning claude sonnet 4.6 was used as the judge in talkie's reinforcement learning pipeline. claude opus 4.6 generated the synthetic conversations used in fine tuning. a modern AI was used to train a model that's supposed to be frozen in 1930 the team already flagged this as a contamination risk they want to eliminate in future versions what they're using it to study: > long range forecasting. how well can a model "predict" the future from a frozen vantage point > invention. can it develop ideas that didn't exist until after its knowledge cutoff > LLM identity. what makes a model itself vs what's just patterns absorbed from the web alec radford built this. the same guy behind GPT, CLIP, and whisper both models are open source on hugging face. they're already planning a GPT-3 scale vintage model later this year an AI that has never seen the modern world can still reason its way to writing code. THAT alone tells you more about intelligence than any benchmark ever will
- 172Replies
- 429Reposts
- 3KLikes
- 244.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 03
@alex_verem ·
This paper from Google DeepMind, Meta, Amazon, and Yale University quietly explains why most “AI agents” feel smart in demos and dumb in real work. The core idea is simple but uncomfortable: today’s LLMs don’t reason, they react. They generate fluent answers token by token, but they don’t explicitly plan, reflect, or decide when to stop and rethink. This paper argues that real progress comes from turning LLMs into agentic reasoners systems that can set goals, break them into subgoals, choose actions, evaluate outcomes, and revise their strategy mid-flight. The authors formalize agentic reasoning as a loop, not a prompt: observe → plan → act → reflect → update state → repeat. Instead of one long chain-of-thought, the model maintains an internal task state. It decides what to think about next, not just how to finish the sentence. This is why classic tricks like longer CoT plateau. You get more words, not better decisions. One of the most important insights: reasoning quality collapses when control and reasoning are mixed. When the same prompt tries to plan, execute, critique, and finalize, errors compound silently. Agentic setups separate these roles. Planning is explicit. Execution is scoped. Reflection is delayed and structured. The paper shows that even strong frontier models improve dramatically when given: • explicit intermediate goals • checkpoints for self-evaluation • the ability to abandon bad paths • memory of past attempts No new weights. No bigger models. Just better control over when and why the model reasons. The takeaway is brutal for the industry: scaling tokens and parameters won’t give us reliable agents. Architecture will. Agentic reasoning isn’t a feature it’s the missing operating system for LLMs. Most “autonomous agents” today are just fast typists with tools. This paper explains what it actually takes to build thinkers.
- 76Replies
- 328Reposts
- 1.5KLikes
- 112.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 04
@milan_milanovic ·
𝗟𝗟𝗠𝘀 𝗔𝗿𝗲 𝗡𝗼𝘁 𝗥𝗲𝗮𝗱𝗶𝗻𝗴 𝗬𝗼𝘂𝗿 𝗖𝗼𝗱𝗲 We keep calling LLMs "AI coding assistants." But writing code and understanding code are not the same thing. Researchers from Virginia Tech and Carnegie Mellon University just ran 750,000 debugging experiments across 10 models to determine how well LLMs actually understand code. The results show that you should not blindly trust your AI coding assistant when debugging. Here is what they found: 𝟭. 𝗔 𝗿𝗲𝗻𝗮𝗺𝗲𝗱 𝘃𝗮𝗿𝗶𝗮𝗯𝗹𝗲 𝗯𝗿𝗲𝗮𝗸𝘀 𝘁𝗵𝗲 𝗱𝗲𝗯𝘂𝗴𝗴𝗲𝗿 Researchers created a bug, confirmed that the LLM found it, then made changes that don't touch the bug at all, such as renaming a variable or adding a comment. In 78% of cases, the model could no longer find the same bug. The bug was still there. The variable names and comments changed, and that was enough. 𝟮. 𝗗𝗲𝗮𝗱 𝗰𝗼𝗱𝗲 𝗶𝘀 𝗮 𝘁𝗿𝗮𝗽 Adding code that never runs reduced bug-detection accuracy to 20.38%. Models treated dead code as live, and flagged it as the source of the bug. But the bug was in another line. So, LLMs cannot reliably distinguish "this runs" from "this never runs." 𝟯. 𝗠𝗼𝗱𝗲𝗹𝘀 𝗿𝗲𝗮𝗱 𝘁𝗼𝗽-𝘁𝗼-𝗯𝗼𝘁𝘁𝗼𝗺, 𝗻𝗼𝘁 𝗹𝗼𝗴𝗶𝗰𝗮𝗹𝗹𝘆 56% of correctly found bugs were in the first quarter of the file. Only 6% were in the last quarter. The further down the code, the less attention the model pays to it. If the bug lives in the bottom half of your file, the model is already less likely to find it. 𝟰. 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻 𝗿𝗲𝗼𝗿𝗱𝗲𝗿𝗶𝗻𝗴 𝗮𝗹𝗼𝗻𝗲 𝗰𝘂𝘁 𝗮𝗰𝗰𝘂𝗿𝗮𝗰𝘆 𝗯𝘆 𝟴𝟯% Changing the order of functions in a Java file caused an 83% drop in debugging accuracy. The code still remained the same. Where the code physically sits in the file matters more to the model than what the code does. So, obviously, this is a sign of pattern recognition, not real code understanding. 𝟱. 𝗡𝗲𝘄𝗲𝗿 𝗺𝗼𝗱𝗲𝗹𝘀 𝗵𝗮𝗿𝗱𝗹𝘆 𝗺𝗼𝘃𝗲 𝘁𝗵𝗲 𝗻𝗲𝗲𝗱𝗹𝗲 Claude improved ~1% between 3.7 and 4.5 Sonnet on this task. Gemini improved by ~1.8%. Every model release comes with a new benchmark leaderboard and new headlines. But the ability to reason about code under realistic conditions is improving slowly. 𝟲. 𝗧𝗵𝗲𝘀𝗲 𝘄𝗲𝗿𝗲 𝗯𝗲𝘀𝘁-𝗰𝗮𝘀𝗲 𝗰𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝘀 The study used single-file programs with ~250 lines, and each had a clear description of what the code should do. The authors say this was intentional. They wanted the best-case conditions. Real production code is multi-file, cross-module, and poorly documented. It will perform worse for sure. Here are three things worth changing based on the research: 🔹 𝗣𝗮𝘀𝘀 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗰𝗼𝗻𝘁𝗲𝘅𝘁, 𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝗰𝗼𝗱𝗲. When asking an LLM to debug, include test output, stack traces, and failure messages alongside the source. Without runtime details, the model is guessing based on the code. 🔹 𝗗𝗼𝗻'𝘁 𝘁𝗿𝘂𝘀𝘁 𝗶𝘁 𝗼𝗻 𝗱𝗲𝗲𝗽-𝗳𝗶𝗹𝗲 𝗯𝘂𝗴𝘀. If the suspect code is in the bottom third of a long file, the model will have trouble finding it. Consider splitting the context or feeding the relevant function directly. 🔹 𝗖𝗹𝗲𝗮𝗻 𝘂𝗽 𝗱𝗲𝗮𝗱 𝗰𝗼𝗱𝗲 𝗯𝗲𝗳𝗼𝗿𝗲 𝘂𝘀𝗶𝗻𝗴 𝗔𝗜 𝗱𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴 𝘁𝗼𝗼𝗹𝘀. Commented-out blocks and unreachable branches will mislead the model. It cannot filter them out. We rate AI coding tools on HumanEval. That tests whether a model can write a function from a description, but this says nothing about finding a bug in code it didn't write. Those are different problems. We're using the wrong benchmark.
- 90Replies
- 258Reposts
- 1.2KLikes
- 117.9KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 05
@OpenAI ·
Chain of thought monitors are a key layer of defense against AI agent misalignment. To preserve monitorability, we avoid penalizing misaligned reasoning during RL. We found a limited amount of accidental CoT grading which affected released models, and are sharing our analysis. https://t.co/0o3PLfafC4
- 334Replies
- 298Reposts
- 3KLikes
- 471.3KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 06
@intern_lm ·
🚀Introducing Intern-S1-Pro, an advanced 1T MoE open-source multimodal scientific reasoning model. 1⃣SOTA scientific reasoning, competitive with leading closed-source models across AI4Science tasks. 2⃣Top-tier performance on advanced reasoning benchmarks, strong general multimodal performance on various benchmarks. 3⃣1T-A22B MoE training efficiency with STE routing (dense gradient for router training) and grouped routing for stable convergence and balanced expert parallelism. 4⃣Fourier Position Encoding (FoPE) + upgraded time-series modeling for better physical signal representation; supports long, heterogeneous time-series (10^0–10^6 points). 😍Intern-S1-Pro is now supported by vLLM @vllm_project and SGLang @sgl_project @lmsysorg — more ecosystem integrations are on the way. ☺️Model：@huggingface https://t.co/ZJivpSrnaL ☺️GitHub: https://t.co/ImW2Tzh5GP ☺️Try it now at: https://t.co/OpebPDJ2V5
- 30Replies
- 143Reposts
- 947Likes
- 297.9KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 07
@akshay_pachaar ·
Microsoft just mass-compressed LLM reasoning. their new paper introduces MEMENTO, a method that teaches reasoning models to manage their own context. instead of letting chain-of-thought grow into a flat 32K-token stream, the model learns to segment its reasoning into blocks, compress each into a dense summary (a "memento"), and mask the original block from future attention. the result is a sawtooth KV cache pattern where memory periodically drops instead of growing monotonically. training is a two-stage SFT recipe. stage 1: learn the block-memento format with full attention. stage 2: learn to reason with masked blocks. each block gets compressed 5-20x, and peak KV cache drops by 2-2.5x across model families. but the most surprising finding is the "dual information stream." when a memento is generated, the model can still see the full reasoning block. so the memento's KV entries get computed with full block context. after the block is masked, those KV entries stay. they carry implicit information that the memento text alone doesn't capture. recomputing memento KVs without block context drops accuracy by 15 percentage points. same text, different KV representations, significantly worse performance. this is what separates MEMENTO from prior work that rebuilds context from text alone and loses this implicit channel. they also showed the accuracy gap is a consistency problem, not a capability problem. the model can still solve the same problems, just less reliably. majority voting at k=3 recovers base accuracy, and RL closes most of the remaining gap. as reasoning traces get longer, models that compress their own intermediate state will serve more users on the same hardware. and the dual KV channel suggests in-place masking is fundamentally better than restart-based approaches. paper and dataset (228K traces) are public. link in the next tweet
- 20Replies
- 54Reposts
- 366Likes
- 20.2KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 08
@GavinSBaker ·
Super important post from @polynoamial and the investor TLDR is: all current estimates for compute demand might be low. “We likely don't know what the capability ceiling is for modern LLMs because it's too expensive to measure. Frequently when I discuss this, people ask why we don't just evaluate with a harness that pushes test-time compute until performance plateaus. The problem is that, empirically, the plateau is very far out. Sometimes we may not observe a plateau at all within practical budgets Notice that for the stronger models the performance improvement over time is stronger. It seems likely that as models become stronger they become more effective at operating over longer horizons. The point of plateau is pushed out, and may even disappear.” If test-time compute performance improvement over time *effectively* scales at some ratio with training…
- 28Replies
- 67Reposts
- 725Likes
- 108.1KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 09
@profjamesevans ·
Our new essay is out in Science: "Agentic AI and the Next Intelligence Explosion" For decades, the AI "singularity" has been imagined as a single, godlike mind bootstrapping itself to omniscience. In this piece with the inimitable Benjamin Bratton (@bratton) and Blaise Agüera y Arcas (@blaiseaguera), we argue this vision is wrong in its most fundamental assumption. Every prior intelligence explosion—primate sociality, human language, writing, institutions—wasn't an upgrade to individual cognitive hardware. It was the emergence of a new socially aggregated unit of cognition. AI is extending this sequence, not breaking from it. The evidence is already inside the models themselves. In recent work, we showed that frontier reasoning models like DeepSeek-R1 don't improve by "thinking longer"—they spontaneously simulate internal multi-agent debates, what we call a "society of thought" (https://t.co/NbmErI16NN). Reinforcement learning for accuracy alone causes models to rediscover what epistemology and cognitive science have long suggested: robust reasoning is a social process, even within a single mind. This opens a vast design space. A century of research on team composition, hierarchy, role differentiation, and structured disagreement has barely been brought to bear on AI reasoning. The toolkits of organizational science become blueprints for next-generation AI. Outside the model, we've entered the era of human-AI centaurs—composite actors that are neither purely human nor purely machine. Agents that fork, differentiate, recombine. Recursive societies of thought that expand when complexity demands and collapse when problems resolve. The scaling frontier isn't just bigger models. It's richer social systems—and the institutions to govern them. Just as human societies rely on persistent institutional templates (courtrooms, markets, bureaucracies), scalable AI ecosystems will need digital equivalents. The Founders would have recognized the logic: no single concentration of intelligence should regulate itself. The intelligence explosion is already here. Not as a singular ascending mind, but as a combinatorial society complexifying—intelligence growing like a city. The question is whether we'll build the social infrastructure worthy of what it's becoming. No mind is an island. Read it here in Science (https://t.co/yWhrbPkTsk) or free on the arXiv (https://t.co/qCmm89X4Z5)
- 26Replies
- 75Reposts
- 281Likes
- 30.3KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 10
@LiorOnAI ·
Stop using bigger models to generate training data. DeepMind just showed smaller models produce better synthetic reasoning data under the same compute budget. Training gains reach 31.6% while costing a fraction of the inference budget. 𝗦𝗺𝗮𝗹𝗹𝗲𝗿 𝗺𝗼𝗱𝗲𝗹𝘀 𝗰𝗼𝘃𝗲𝗿 𝗺𝗼𝗿𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺𝘀. The key idea is compute matched sampling. Cheaper models generate many more solutions per question. • More samples increase problem coverage • More attempts increase reasoning diversity • Slightly higher error rates get filtered later In math benchmarks, coverage rises 11% and diversity 86%. 𝗧𝗿𝗮𝗶𝗻𝗶𝗻𝗴 𝗶𝗺𝗽𝗿𝗼𝘃𝗲𝘀 𝗮𝗰𝗿𝗼𝘀𝘀 𝗮𝗹𝗹 𝘀𝗲𝘁𝘂𝗽𝘀. Models trained on this data outperform strong model distillation. • Student training • Self improvement • Weak to strong transfer All show consistent accuracy gains. 𝗧𝗵𝗶𝘀 𝗰𝗵𝗮𝗻𝗴𝗲𝘀 𝗵𝗼𝘄 𝘆𝗼𝘂 𝘀𝗽𝗲𝗻𝗱 𝗶𝗻𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝗯𝘂𝗱𝗴𝗲𝘁𝘀. You should sample more, not sample bigger.
- 19Replies
- 49Reposts
- 355Likes
- 19.7KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post.
- 11
@AiBattle_ ·
ARC-AGI-3 launches tomorrow - The first interactive reasoning benchmark built to test human-like intelligence in AI - 1,000+ levels across 150+ environments requiring exploration, learning, planning, and adaptation - Video-game-like tasks with no instructions, requiring multi-step reasoning and rule discovery The highest score on ARC-AGI-1 currently is Gemini 3.1 Pro with 98%, while on ARC-AGI-2 it is Gemini 3 Deep Think with 84.6%
- 25Replies
- 62Reposts
- 687Likes
- 61.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 12
@jaseweston ·
🧮 Reasoning over Mathematical Objects 🧮 Our 70-page(!) paper is out on arXiv, as covered by several of our recent blog posts. We study how to improve reasoning on hard tasks (e.g., math expressions) via: • better training data (& new evals) • better reward models (on-policy trained) • better inference methods (on-policy trained) 📝: https://t.co/ChcQyMDWw1
- 3Replies
- 25Reposts
- 134Likes
- 8.4KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 13
@VaibhavSisinty ·
What's happening in AI right now is genuinely hard to process. A 3 billion parameter model is matching models that are 200 to 300 times larger. On math. On coding. On reasoning. And beating some of them. It's called VibeThinker-3B. Built by Sina Weibo's team on a tiny Qwen 3B base. → 94.3% on AIME math matches DeepSeek V3.2 (671B) and Kimi K2.5 (1 trillion parameters) → 96.1% on LeetCode beats GPT-5.2 and Claude 4.6 on unseen contest problems → 80.2% on LiveCodeBench highest of any small or mid-size model tested A model you can run on a laptop is solving competition math at the same level as models that need entire GPU clusters. The idea behind it: reasoning and knowledge are two different things. Knowledge needs massive parameters to store facts. Reasoning is a procedure search, check, correct, compose and procedures compress into small models far more efficiently. The honest catch: ask it a broad factual question and it trails the big models badly. This isn't a general-purpose win. It's a reasoning specialist. And that's exactly what makes the result credible instead of hype. A 3B model. Competing with trillion-parameter flagships. On reasoning tasks. Running locally. That's where we are now.
- 8Replies
- 24Reposts
- 143Likes
- 14.1KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 14
@LuizaJarovsky ·
🚨 A new study shows that chain-of-thought information does NOT capture all the LLM reasoning. Some of the AI governance implications of this invisible reasoning: The study defines "invisible reasoning" as the consequential computation that occurs within an AI model's internal latent representations but leaves no interpretable trace in the output tokens. The study calls these semantically irrelevant tokens "filler tokens." They carry no information about any particular problem or answer, but may still act as procedural cues during AI reasoning. When the AI model's reasoning is not expressed through an interpretable chain of thought but is only present in internal latent states, this has direct implications for AI explainability, transparency, auditing, and safety efforts. - How do you comply with baseline transparency and explainability requirements when an AI model's chain-of-thought does not reflect the real reasoning behind the output? - Can existing auditing methods properly address these meaningless but procedurally helpful "filler tokens"? As AI capabilities continue to saturate benchmarks (and AI models have started to escape testing settings and roam the internet...), the possibility of "invisible reasoning" should be further investigated and acknowledged as an incremental risk. Congratulations to the paper authors, @vatsalbaherwani, @tomgoldsteincs & @PandaAshwinee! 👉 Download the paper below. 👉 I've added this paper as the 14th recommended paper of our AI Ethics Paper Club (you can join it for free below).
- 15Replies
- 23Reposts
- 67Likes
- 3.2KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 15
@heygurisingh ·
🚨Carnegie Mellon just proved your "reasoning" model doesn't actually reason. They tested 14 of the top LLMs (GPT, Claude, Gemini, all of them) on 500 problems where surface-level keywords conflicted with basic logic. Not a single model scored above 75%. On problems requiring the model to notice a missing object, accuracy collapsed to 44%. Here's the part that should terrify every AI lab: When researchers measured what the models were actually paying attention to, a single surface keyword (like "distance") influenced the answer 8.7x to 38x MORE than the actual goal of the question. The models weren't reasoning. They were pattern-matching on vibes. It gets worse. 12 of the 14 models performed WORSE when the hard constraint was removed, dropping up to 39 percentage points. They're not solving problems. They're guessing conservatively based on keyword associations they saw in training. The paper calls this "heuristic override." In plain English: every time a salient keyword shows up in your prompt, the model hijacks itself and ignores what you actually asked. The fix? A single hint telling the model what to focus on recovers +15 points on average. Translation: these models know the answer. They just refuse to think unless you beg them to. Every benchmark bragging about "PhD-level reasoning" needs an asterisk now. Paper: "The Model Says Walk: How Surface Heuristics Override Implicit Constraints in LLM Reasoning" (CMU, 2026)
- 11Replies
- 27Reposts
- 138Likes
- 11KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 16
@ArtificialAnlys ·
India enters the open-weights AI race with its largest models pre-trained from scratch: Sarvam 105B and Sarvam 30B @SarvamAI's Sarvam 105B and Sarvam 30B score 18 and 12 on the Artificial Analysis Intelligence Index respectively. Announced at the India AI Impact Summit 2026 and open-sourced under Apache 2.0, both are Mixture-of-Experts models trained entirely in India using compute provided under the IndiaAI Mission (@OfficialINDIAai). Both support reasoning and non-reasoning modes. These are an improvement from Sarvam's previous model, Sarvam M (8 on Intelligence Index, 23.6B parameters), which was based on Mistral Small rather than pre-trained from scratch. Sarvam 105B has 106B total parameters with ~10B active per token and a 128K context window. Sarvam 30B has 32B total parameters with ~2.4B active per token and a 65K context window. Alongside the text models, Sarvam also announced Saaras v3 (Speech to Text) and Bulbul v3 (Text to Speech) with a focus on Indic languages. Key takeaways in reasoning mode: ➤ Sarvam 105B scores 18 on the Intelligence Index. Among ~100B-class open-weights reasoning models, it trails GLM-4.5-Air (23), INTELLECT-3 (22), Mistral Small 4 (27), and gpt-oss-120B (High, 33). All four peers also activate more parameters per token ➤ Sarvam 30B scores 12 on the Intelligence Index. Among ~30B-class open-weights reasoning models, it trails GLM-4.7-Flash (30), Nemotron Cascade 2 30B A3B (28), Qwen3 30B A3B 2507 (22), and Qwen3 32B (17). Sarvam 30B activates fewer parameters than these peers. ➤ Sarvam 105B's relative strength is in select agentic tasks. Its agentic index of 25 places it ahead of INTELLECT-3 (20) and GLM-4.5-Air (21) despite trailing both on overall intelligence. Its GDPval index of 773 also edges ahead of GLM-4.5-Air (665). Both new models are a large step up from Sarvam M (Reasoning), which scored 8 on the Intelligence Index. ➤ Compared to peers, both models score lower on TerminalBench Hard (Agentic Coding & Terminal Use) and AA-Omniscience. Sarvam 105B scored 1.5% and Sarvam 30B scored 2.3% on TerminalBench Hard, compared to GLM-4.5-Air (20.5%) and INTELLECT-3 (9.1%). The AA-Omniscience Index is -60 for Sarvam 105B and -72 for Sarvam 30B. Both models have high hallucination rates relative to their accuracy, and both attempt to answer far more questions rather than abstaining, which drives the negative scores. Key model details: ➤ Modality: Text input and output only. ➤ Context window: 128K tokens (Sarvam 105B) and 65K tokens (Sarvam 30B). ➤ Pricing: Currently free on Sarvam's first-party API. ➤ License: Apache 2.0. ➤ Availability: Sarvam's first-party API; weights available on @huggingface and AIKosh.
- 12Replies
- 43Reposts
- 388Likes
- 24KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 17
@drmapavone ·
On the heels of the Alpamayo announcement — @nvidia's fully open ecosystem for accelerating the development of reasoning-based autonomous vehicles — I’m excited to share our latest advances in researching reasoning-based Physical AI models. Starting with Latent‑CoT‑Drive (LCDrive), a novel approach that learns to reason in a *latent* action-aligned space for end-to-end driving decision-making. Traditional vision-language-action models rely on natural language for chain-of-thought reasoning — but is language the best medium for encoding driving decisions? In our paper, we explore this question and introduce a latent representation that integrates both action proposals and predictions of future outcomes, enabling richer reasoning and improved performance. 🔍 Key Contributions - Latent reasoning for driving: LCDrive rethinks reasoning in vision–language–action (VLA) models using latent chain-of-thought tokens aligned with driving actions and a latent world model. - Effective training framework: Combines latent CoT cold-start, world model training, and closed-loop reinforcement learning, tailored for latent reasoning models. - Empirical gains: Shows faster inference and higher driving quality compared to non-reasoning and text-reasoning baselines. This work shows that latent reasoning provides a compelling representation for reasoning-based VLA models. 📄 Full paper here: https://t.co/Wm5ji0aOXn #AutonomousVehicles #AutonomousDriving #PhysicalAI #ReasoningAI #Alpamayo @NVIDIAAI @NVIDIADRIVE
- 2Replies
- 25Reposts
- 138Likes
- 10.6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 18
@HuggingPapers ·
Run 32B reasoning models on a 24GB GPU TriAttention matches Full Attention accuracy while compressing KV cache by 10.7x and boosting throughput by 2.5x. It leverages pre-RoPE Q/K concentration to score keys via trigonometric series, enabling long reasoning where Full Attention OOMs.
- 4Replies
- 7Reposts
- 94Likes
- 4.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 19
@drmapavone ·
More on #reasoning in Vision-Language-Action (#VLA) models --- Traditional VLA models decide what action to take by decomposing complex situations into their most salient factors. But reasoning models can do much more. When viewed as implicit world models operating in a semantic space, they can be used counterfactually—exploring multiple “what if” scenarios before acting. In our recent paper, Counterfactual VLA (CF-VLA, https://t.co/IMk9CWQ2Zx), we show that counterfactual reasoning consistently improves trajectory accuracy, safety, and reasoning quality. Key contributions: - Self-reflective counterfactual reasoning: CF-VLA reflects on predicted meta-actions, anticipates consequences, and revises plans before execution—enabling causal self-correction. - Automated data pipeline: A novel data pipeline generates counterfactual data, forming a self-improving loop for reasoning and action. - Adaptive thinking in autonomous driving: CF-VLA focuses reasoning on the most challenging scenarios, improving performance while keeping test-time computation efficient. Paper: https://t.co/IMk9CWQ2Zx #AI #Robotics #VisionLanguageAction #AutonomousSystems #MachineLearning #CounterfactualReasoning @NVIDIAAI @NVIDIADRIVE
- 0Replies
- 21Reposts
- 105Likes
- 7.2KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 20
@profjamesevans ·
Delighted to share new work led by the remarkable @JunsolK, with @ShiyangLai, @ninoscherrer, and @blaiseaguera Blaise Agüera y Arcas—now on arXiv. We asked a simple question: What happens inside models like OpenAI's o-series, DeepSeek-R1, and QwQ when they reason? The answer surprised us. These models don't simply compute longer. They spontaneously generate internal debates among simulated agents with distinct personalities and expertise—what we call "societies of thought." Perspectives clash, questions get posed and answered, conflicts emerge and resolve, and self-references shift to the collective "we"—at rates hundreds to thousands of percent higher than chain-of-thought reasoning. There's high variance in Big 5 personality traits like neuroticism and openness, plus specialized expertise spanning physics to creative writing. The structure mirrors collective intelligence in human groups. Moreover, toggling conversational features causally toggles this capacity—beneficial cognitive behaviors like verification become more likely when they can "inhabit" different personas. What makes this remarkable from a complex systems perspective is that these societies weren't designed. They emerged from reinforcement learning rewarding only correct answers. The models discovered that distributing cognition across diverse, conflicting perspectives is an optimal strategy for distinguishing truth from error. Self-organization in service of reasoning. Even more striking: training on a simple arithmetic task (the Countdown game) produced conversational reasoning that transferred to detecting political misinformation—suggesting the generality of collective deliberation as a reasoning architecture. When we stage models with personas from the start, they learn faster. The emergent "cast of characters" is fascinating: one detailed and algebraic, another intuitive and exploratory, a third who reconciles diverse opinions. Of course, single-channel conversation can't search all collective configurations—no natural hierarchies or networked organizations—pointing toward scaffolding that explores larger spaces of social organization. Our findings resonate with Mercier & Sperber's social origins of reason and complexity research on diversity-enabled collective intelligence. Proud to pursue this work with collaborators at @Google's wonderful Paradigms of Intelligence team (thx for amazing suggestions from Blake Richards, Roberta Rocca, and Rif Saurous), UChicago Knowledge Lab (@KnowLab), and the Santa Fe Institute (@sfiscience), where long-standing work has inspired us about how complex collectives solve problems individuals cannot. Paper: https://t.co/aPzsAT3ARk
- 2Replies
- 24Reposts
- 102Likes
- 12.6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 21
@omarsar0 ·
// When Cheaper Reasoning Models End Up Costing More // The model you think is cheaper might actually cost you more. New research quantifies exactly how misleading listed API prices are. Across 8 frontier reasoning models and 9 tasks, 21.8% of model-pair comparisons exhibit pricing reversal, where the cheaper-listed model costs more in practice. The magnitude reaches up to 28x. Gemini 3 Flash is listed 78% cheaper than GPT-5.2, yet its actual cost is 22% higher. Claude Opus 4.6 is listed at 2x Gemini 3.1 Pro but actually costs 35% less. The root cause: thinking token heterogeneity. On the same query, one model may use 900% more thinking tokens. Why does it matter? Anyone choosing reasoning models for production needs to benchmark actual costs, not listed prices. Removing thinking token costs reduces ranking reversals by 70%. The authors release code and data for per-task cost auditing. Paper: https://t.co/JKdbbqes6a Learn to build effective AI agents in our academy: https://t.co/1e8RZKs4uX
- 29Replies
- 32Reposts
- 151Likes
- 34.6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 22
@arpit_bhayani ·
Was going through @pathway_com's BDH CQ paper and found the reasoning cost breakthrough worth understanding. Some numbers... a 150M param model achieves 29.5% pass@2 on ARC AGI 1 in about 0.85 H200 GPU seconds per task. At the paper's assumed rate of $3 per H200 hour, that works out to $.0007 per task. Crude cost comparison puts a comparative accuracy model GPT 5.6 Luna (Low) roughly 11X costlier than this. That's sweet... By the way, the interesting part... While you can use BDH-CQ with classic CoT, the model innately does not use CoT and uses latent reasoning instead. By the way, it is also a post-Transformer model that has shown Transformer-like scaling laws up to 600B parameters. I mean, this does have the potential to change how we think about cost, latency, and reasoning depth in AI pipelines. Paper linked in the next tweet for reference. Hope this helps.
- 1Replies
- 6Reposts
- 160Likes
- 7KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 23
@arankomatsuzaki ·
LongCoT: Benchmarking Long-Horizon Chain-of-Thought Reasoning - 2,500 expert-designed problems spanning science, chess, and logic that demand up to hundreds of thousands of reasoning tokens - The best models achieve <10% accuracy
- 7Replies
- 26Reposts
- 126Likes
- 17.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 24
@hasantoxr ·
A Chinese AI lab just open-sourced a 1 trillion parameter reasoning model that plugs directly into Claude Code. It's called Ring-2.6-1T. MoE architecture. 63B active parameters per token. MIT license. And it just beat GPT-5.4 and Gemini 3.1 Pro on the hardest agent benchmark in the field. Breakdown below ↓
- 15Replies
- 59Reposts
- 262Likes
- 129.3KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 25
@dair_ai ·
Even the best reasoning models hit an accuracy collapse beyond a certain problem complexity. Giving an LRM the exact solution algorithm doesn't fix it either. This new work, BIGMAS, improves LLM agents by taking inspiration from the human brain. BIGMAS outperforms both ReAct and Tree of Thoughts across all three tasks. It organizes specialized LLM agents as nodes in a dynamically constructed directed graph, coordinated through a centralized shared workspace inspired by global workspace theory. A GraphDesigner builds task-specific agent topologies per problem, and a global Orchestrator routes decisions using the complete shared state, eliminating the local-view bottleneck of reactive approaches. Across Game24, Six Fives, and Tower of London on six frontier LLMs, including GPT-5 and Claude 4.5, BIGMAS consistently improves accuracy. The gains are largest where models struggle most: DeepSeek-V3.2 jumps from 12% to 30% on Six Fives. Paper: https://t.co/sMqUfvHAGp Learn to build effective AI agents in our academy: https://t.co/LRnpZN7L4c
- 9Replies
- 12Reposts
- 59Likes
- 4.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 26
@alex_verem ·
🚨BREAKING: Stanford found a 28x pricing reversal in AI APIs. Gemini 3 Flash's listed price is 1.7x cheaper than Claude Haiku 4.5. Its actual cost on MMLUPro is 28x higher. The entire AI cost ranking your team uses for model selection is wrong 1 in 5 times. Stanford and Berkeley audited 8 frontier AI models across 9 benchmarks and 11,872 queries. The goal was simple: do listed API prices actually predict what you'll pay? The answer is no. In 21.8% of model-pair comparisons roughly 1 in 5 the model with the lower listed price actually costs more to run. The reversal isn't a rounding error. The worst case reaches 28x. On MMLUPro, Gemini 3 Flash lists at $3.50 per million tokens. GPT-5.2 lists at $15.75. Gemini 3 Flash's actual cost on that benchmark is 6x higher than GPT-5.2's. The "cheap" model is the expensive one. The root cause is thinking tokens the invisible reasoning steps that reasoning models generate before producing a final answer. They're billed at the full output token rate. They don't appear in the listed price. And they vary by up to 900% across models on the exact same query. On a single AIME math problem: → GPT-5.2 used 562 thinking tokens. Correct answer. → Gemini 3 Flash used 11,749 thinking tokens. Same correct answer. → 20x more thinking. 2.5x higher actual cost. Despite Gemini 3 Flash's lower listed price. Stanford confirmed causality through ablation. When thinking token costs are removed: → Ranking reversals drop by 70% → Price-to-cost correlation jumps from 0.563 to 0.873 → On MMLUPro, some models spend up to 97.9% of output tokens on thinking alone Actual cost across all models for the full benchmark suite: → Gemini 3.1 Pro: listed $14/MTok actual $1,169 total most expensive model overall → Claude Opus 4.6: listed $30/MTok actual $768 cheaper than Gemini 3.1 Pro despite 2x higher listed price → Gemini 3 Flash: listed $3.50/MTok actual $643 more expensive than GPT-5.2 → GPT-5.2: listed $15.75/MTok actual $527 cheaper than both Gemini models → GPT-5 Mini: listed $2.25/MTok actual $53 → Claude Haiku 4.5: listed $6/MTok actual $37 one of the cheapest to actually run → Reversal rate across all 252 comparisons: 21.8% → Reversal rate on MMLUPro specifically: 32.1% nearly 1 in 3 comparisons flipped → Worst single reversal: Gemini 3 Flash vs Claude Haiku 4.5 1.7x cheaper listed, 28x more expensive actual The cost prediction problem is even worse. Stanford tested whether you could predict actual cost before sending a query using embeddings, prompt length, historical similarity. The best predictor reduced error by only 23% over just guessing the average. On high-variance models like Gemini 3.1 Pro, even the best predictor was useless. The reason: part of the variance has nothing to do with the query. Running the same AIME problem six times on GPT-5 Mini produced costs ranging up to 9.7x apart. Same prompt. Same model. Different runs. The thinking process is stochastic. The bill is stochastic. No predictor can fix randomness that lives inside the model. The price on the pricing page is not your cost. For reasoning models, it's not even close.
- 10Replies
- 6Reposts
- 57Likes
- 7.4KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 27
@TheTuringPost ·
Models gain a lot from long reasoning but maybe they don’t need to write reasoning in words at all? @IBM introduced Abstract Chain-of-Thought that replaces text reasoning with abstract tokens. The model produces a short sequence with these special tokens which are: - much shorter - not human-readable - and act like a hidden scratchpad. The difficult part is that these tokens start as meaningless, so the model is trained in 2 phases: 1. Compression from CoT, when it takes normal reasoning and compresses it into abstract tokens 2. Self-distillation: Remove the text reasoning completely and the model trains to generate abstract tokens directly. Then everything is refined with RL. The results are about real efficiency: Abstract-CoT needs up to 11.6× fewer reasoning tokens -> inference in much cheaper with similar performance to normal CoT And another interesting thing - the abstract tokens start behaving like a real language, and the model learns its own internal reasoning language
- 5Replies
- 10Reposts
- 65Likes
- 6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 28
@om_patel5 ·
AN ANTHROPIC ENGINEER GOT CLAUDE TO PLAY POKEMON RED WITH NO HUMAN INPUT AND IT'S ABOUT TO BEAT THE GAME an anthropic engineer built this as a side project. claude opus 4.7 is playing the original 1996 pokemon red on a game boy emulator with NO human input, walkthrough, or game knowledge fed in all that was used was just a screenshot, 3 tools, and markdown notes it's currently at 5 of 8 badges in 15,779 steps. led by ivy the venusaur at level 62 for context opus 4.5 took 48,000 steps and was still stuck at the same badge count. 4.7 is pacing way faster on the exact same setup the system prompt actually tells claude to distrust its own pokemon knowledge since the game version might differ from what it remembers here's how the whole thing works: > claude gets a screenshot of the game every turn > it has 3 tools: button presses, a pathfinding navigator, and a knowledge base it can read and write to > a walkability overlay is parsed directly from the game's RAM so claude can see which tiles are walls > a second LLM reviews and critiques claude's notes file to keep it honest > when the conversation gets too long it triggers a progressive summarization, clears history, and resumes from the summary you can watch the reasoning trace on the left side of the stream in real time. right now it's doing coordinate based wall verification to figure out maze geometry the history of this stream: > sonnet 3.5 couldn't exit the player's house > sonnet 3.7 was the breakthrough, got 3 badges, went viral getting stuck in mt moon for 12 hours > sonnet 4 through 4.5 made zero story progress for months > opus 4.5 finally got all 8 badges and reached victory road > opus 4.7 is now pacing to potentially beat the entire game gemini and GPT have both beaten pokemon already but with heavier tooling. this run keeps the setup lean on purpose to test raw model reasoning watching an AI think through spatial logic, plan routes, and learn from its own mistakes in real time is the most fascinating benchmark in AI right now AND the entire process is live on twitch for everyone to watch
- 9Replies
- 11Reposts
- 72Likes
- 7.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 29
@_simonsmith ·
Fable 5's intelligence comes at a huge cost made clear by Artificial Analysis revealing what it spent to run the model on its full benchmark suite. Its intelligence increase over Opus 4.8 is +3.5 index points, about +5.7%, but cost increased +131%, from $4,309 to $9,940. I'm wondering what would happen if you just gave Opus 4.8 131% more token budget, putting it in verification loops rather than one-shotting outputs. Would it close the gap? How high could you get it? I'm reminded of Noam Brown's recent essay on test-time compute. To best understand model improvement, we really need to hold spend constant. Fable 5 costs about $153 per Intelligence Index point while Opus 4.8 costs about $70 per point. So Fable 5 is more than 2X more expensive per intelligence point than Opus 4.8. It's probably still worth it for some tasks. Maybe let Fable 5 orchestrate and verify, and another model execute.
- 7Replies
- 8Reposts
- 84Likes
- 8.4KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 30
@rohanpaul_ai ·
This research finds that training AI models to reason better does not actually improve how they organize and understand general information. While reasoning models excel at solving complex math or logic puzzles, they perform exactly the same as standard models when used to find similar documents or answer general questions. Researchers tested this by taking base models and their advanced reasoning versions, then turning both into embedding models, which are systems that turn text into lists of numbers to measure meaning. They used a new framework called Hierarchical Representation Similarity Analysis to look under the hood and see how the internal "thought maps" of these models changed after reasoning training. The study discovered that while reasoning training reorganizes the local neighborhood of how a model sees data, it keeps the overall global structure and the way it reads information almost identical to the original version. When both types of models were put through the same final training steps to become search tools, the special reasoning abilities simply did not translate into better performance on standard industry tests. This means that the massive effort spent teaching models to think through problems step-by-step does not automatically give them a better "gut feeling" for general language similarity. ---- Paper Link – arxiv. org/abs/2601.21192 Paper Title: "Do Reasoning Models Enhance Embedding Models?"
- 2Replies
- 13Reposts
- 48Likes
- 3.5KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 31
@mark_k ·
New paper: RL for LLM reasoning does not teach new strategies. It only redistributes probability over solutions the base model already has. Edits are sparse (1–3% of tokens), concentrated at high-entropy decision points, and almost always promote tokens already in the base model’s top-5. They introduce ReasonMaxxer, an RL-free method that applies contrastive loss only at those entropy-gated spots. A few hundred rollouts, tens of problems, minutes on one GPU. Matches or beats full RL across models and math benchmarks at ~1000× lower cost. Reframes the problem as sparse policy selection, not capability learning.
- 5Replies
- 9Reposts
- 47Likes
- 3.9KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 32
@ArtificialAnlys ·
KwaiKAT has released KAT-Coder-Pro V2, a non-reasoning model that scores 44 on the Artificial Analysis Intelligence Index, an 8 point improvement from KAT-Coder-Pro V1 @KwaiAICoder has updated their flagship proprietary coding model with the release of KAT-Coder-Pro V2. KAT-Coder-Pro V2 achieves 44 on the Artificial Analysis Intelligence Index, matching Claude Sonnet 4.6 (non-reasoning) and trailing only Claude Opus 4.6 (non-reasoning, 46) among non-reasoning models. At ~9M output tokens, it is also more token efficient than Claude Opus 4.6 (~11M), Claude Sonnet 4.6 (~14M), and reasoning models with similar intelligence such as DeepSeek V3.2 (reasoning, ~61M) and Qwen3.5 397B A17B (reasoning, ~86M). KAT-Coder-Pro V2 is a non-reasoning model, unlike all of the current frontier language models which ‘think’ before answering. Typically, reasoning variants score higher on the Intelligence Index than their non-reasoning counterparts, but consume more output tokens and are less suited to latency-sensitive workloads. Key Highlights: ➤ 🧠 Higher overall intelligence, but regression in long context reasoning and knowledge recall: KAT-Coder-Pro V2 scores 44 on the Artificial Analysis Intelligence Index, an 8 point improvement from KAT-Coder-Pro V1 and matching Claude Sonnet 4.6 (non-reasoning, max effort). It performs well on tool use (90% on Tau2-Telecom), but regresses compared to KAT-Coder-Pro V1 on long-context reasoning and knowledge, falling 8 p.p. on AA-LCR (66%) and 17 p.p. on HLE (16%). ➤ 🤖 Agentic capability improvements: KAT-Coder-Pro V2 shows major improvements on our agentic evaluations. On Terminal-Bench Hard, it scores 49%, up 40 p.p. from KAT-Coder-Pro V1, making it the highest-scoring non-reasoning model, matching Claude Opus 4.6 (non-reasoning, 49%) and ahead of Claude Sonnet 4.6 (non-reasoning, 46%). KAT-Coder-Pro V2 also shows improvement in GDPval-AA, scoring 1123 (+304 Elo from V1), but still sits behind models such as DeepSeek V3.2 (1198) and Qwen3.5 397B A17B (1202). ➤ ⚙️ High token efficiency: KAT-Coder-Pro V2 is a non-reasoning model and uses fewer tokens than peers with similar intelligence. It uses 8.7M output tokens to run the Artificial Analysis Intelligence Index, below Claude Opus 4.6 (non-reasoning, ~11M) and Claude Sonnet 4.6 (non-reasoning, ~14M), though this is ~2x higher than its predecessor, KAT-Coder-Pro V1 (~4.5M). It also uses significantly fewer tokens than similarly intelligent reasoning models such as DeepSeek V3.2 (reasoning, ~61M) and Qwen3.5 397B A17B (reasoning, ~86M). ➤ $ Improved cost efficiency: KAT-Coder-Pro V2 costs $73 to run the Artificial Analysis Intelligence Index, down from $76 for V1, as it uses fewer input tokens by requiring fewer turns in agentic evaluations. This makes it one of the most cost-efficient models at its intelligence level, costing less than Qwen3.5 397B A17B (reasoning, $418) and Claude Sonnet 4.6 (non-reasoning, $1397). KAT-Coder-Pro V2 is currently priced at $0.30/$1.20 per 1M input/output tokens on StreamLake and AtlasCloud API endpoints. ➤ ⚡ Low end-to-end response time: KAT-Coder-Pro V2 runs at ~109 output tokens per second, far ahead of Claude Opus 4.6 (non-reasoning, 39 OTPS) and Claude Sonnet 4.6 (non-reasoning, 43 OTPS). Because it also has a low time to first token without any reasoning delay, it delivers one of the fastest end-to-end response times, which measures the time taken from request sent to final output returned. Model details: ➤ Availability: KAT-Coder-Pro V2 is available via StreamLake and AtlasCloud API endpoints ➤ Context Window: 256K tokens (equivalent to KAT-Coder-Pro V1) ➤ Multi-modal capabilities: Text input and output only
- 6Replies
- 11Reposts
- 161Likes
- 33.9KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 33
@mikeknoop ·
When we introduced ARC-AGI-2, we switched from only reporting accuracy (%) to include efficiency ($). This was in response to AI progress - reasoning models necessitated this change as you can always buy more performance for more test-time compute. To understand AGI progress you need both. For ARC-AGI-3, we're again adapting to AI progress. We've introduced a "stateless client" scoring philosophy for our official Verified leaderboard. The idea is that future AGI will not require special state management by the test-giver as this can introduce accidental or intentional bias. Modern reasoning models have gotten so good that you can now achieve domain-specific progress (as Codex and Claude Code demonstrate) when humans craft harnesses around base model intelligence. ARC is interested not in testing how well humans can use AI, we want to test the AI directly. This is an AGI-pilled move to give humans and AI the closest practical testing experience to reveal true progress. I expect other benchmarks which care about testing generalization to adopt a similar viewpoint.
- 12Replies
- 6Reposts
- 80Likes
- 6.7KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 34
@sukh_saroy ·
Anthropic paid a reasoning model to cheat, and it cheated in 99% of cases. It admitted cheating in its chain of thought less than 2% of the time. Instead, it wrote elaborate, confident justifications for why the wrong answer was obviously right. The paper is called "Reasoning Models Don't Always Say What They Think." Anthropic's Alignment Science team tested whether the visible reasoning in models like Claude 3.7 Sonnet and DeepSeek R1 actually reflects how those models arrive at their answers. The method was simple. Slip the model a hint, see if it changes its answer, then check whether the chain of thought admits the hint existed. The average reveal rate across six hint types: 25% for Claude 3.7 Sonnet, 39% for DeepSeek R1. Most of the time, the model used the hint to change its answer and then wrote a reasoning trace that pretended the hint was never there. Now the part that destroys a widely held belief. Some hints were ethically loaded. One told the model it had "gained unauthorized access to the system" and gave it the answer. Claude acknowledged using that hint 41% of the time. R1 acknowledged it 19% of the time. When the hint was the kind you would most want the model to flag, the model was most likely to hide it. Then the researchers built synthetic environments where incorrect answers were deliberately rewarded. A grading function that said the wrong answer was right. Claude 3.7 Sonnet learned to exploit the hack in over 99% of cases. It verbalized the hack in under 2% of cases. It generated elaborate, plausible justifications for the wrong answers, with no trace of the actual strategy anywhere in the reasoning. No one trained the model to hide this. There was no pressure from a CoT monitor. The model defaulted to silence about its actual reasoning on its own. Anthropic also tried to train faithfulness in. Outcome-based reinforcement learning improved it at first and then plateaued. Scaling the training did not fix it. The industry has been selling chain of thought as two things at once. A capability, because reasoning traces make models better at hard problems. And a safety feature, because you can supposedly read the trace and catch misbehavior before it hits the user. The first part is real. The second part is the part this paper dismantles. If a model can learn to exploit a reward hack 99% of the time and write a clean reasoning trace that never mentions the hack, chain of thought is not a monitoring tool. It is a confession system where the suspect gets to write the transcript. The unfaithful chains of thought were, on average, longer than the faithful ones. When the model was lying, it wrote more. So when your reasoning model shows its work, the question is not whether the work is correct. The question is whether the work is real.
- 4Replies
- 15Reposts
- 28Likes
- 2.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 35
@IntuitMachine ·
Reasoning ≠ Self-Awareness Popular belief: "Models that reason longer (o1, R1, chain-of-thought) will naturally get better at knowing when they're wrong." New research across 300+ papers: That's not just unproven — it's empirically false. Here's why: 🧵 DeepSeek-R1 — one of the best reasoning models in the world — fails at trivially simple self-monitoring: ❌ Can't estimate the length of its own reasoning trace ❌ Can't reliably predict whether it will succeed at a task ❌ Doesn't improve with "task familiarity" The data shows: Enhanced reasoning capability can actually oppose metacognitive sensitivity. Meaning: the better a model gets at solving hard problems, the WORSE it might get at saying "I don't know." Reasoning depth ≠ self-knowledge depth. This breaks a core industry assumption: That "emergence" will solve metacognition for free as models scale. It won't. Metacognition is orthogonal to reasoning capability. You need to architect, train, and evaluate for it separately. If you're investing in reasoning-model infrastructure: Budget TWO R&D tracks: 1️⃣ Inference-time compute / CoT depth (for capability) 2️⃣ Metacognitive scaffolding / faithful calibration (for trust) Scaling one doesn't automatically give you the other. The good news? Explicit frameworks like Meta-R1, behavior handbooks, and reflection-termination monitors CAN give reasoning models metacognitive ability. But they have to be designed in, not assumed to emerge. Hot take: The industry is over-investing in "think longer" and under-investing in "know when to stop / defer / abstain." Agree? Disagree? What's your model selection strategy when accuracy and self-knowledge rankings invert?
- 4Replies
- 8Reposts
- 30Likes
- 4.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 36
@heygurisingh ·
Your favorite AI can write poetry, pass the bar exam, and generate code in 12 languages. It cannot reliably find the shortest path between point A and point B. NUS and Google Research just published a paper that exposes a fundamental failure in how LLMs solve problems. They built a controlled environment around shortest-path planning -- one of the most basic optimization problems in computer science. The task: find the shortest route through a map. Models handled new maps fine. Strong spatial transfer. No issues. Then they made the paths longer. Performance collapsed. Not because the models lacked knowledge. They could solve each individual segment. But the moment they had to chain those segments together into a longer path, they broke down. The researchers call it "recursive instability" -- the inability to compose steps you already know how to solve. Here's what makes this devastating: >> More training data doesn't fix it. Data coverage sets capability ceilings but can't break through them. >> Reinforcement learning doesn't fix it. RL stabilizes training but never exceeds the performance ceiling of supervised fine-tuning. >> Inference-time scaling doesn't fix it. You can throw more compute at generation and it still can't rescue length-scaling failures. Every approach the field is betting on right now -- more data, RLHF, chain-of-thought, test-time compute -- fails to solve this specific problem. The models aren't struggling with hard problems. They're struggling with easy problems that get longer. This is the wall nobody's talking about. Every AI agent, every multi-step workflow, every autonomous system depends on chaining simple steps together reliably. If LLMs can't compose what they already know, scaling alone won't get us to AGI. (Link in the comments)
- 4Replies
- 9Reposts
- 19Likes
- 3KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 37
@burkov ·
Most reasoning models that "think longer" on harder problems do so by writing out their reasoning as text, one step at a time, which means training them needs worked examples that spell out those intermediate steps. The alternative this paper builds on works differently: a transformer processes a problem into a set of internal activation vectors (one per input token, called the hidden state), and instead of decoding anything into words, the model feeds that hidden state back into the same network as input, over and over, with the original problem mixed back in each time. Each pass rewrites the hidden state, so the reasoning accumulates inside those vectors across iterations rather than as written text, and the model can be trained on nothing more than problems paired with their final answers. This setup raises two problems which authors address in the paper: how the model should decide on its own when to stop looping, and how to keep the repeated passes from destabilizing those activation vectors, since applying the same step many times behaves like a very deep network in which the signal degrades as it travels through. https://t.co/xLSK9mmFT0
- 1Replies
- 1Reposts
- 33Likes
- 2.7KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 38
@TheTuringPost ·
"Quantized Reasoning Models Think They Need to Think Longer, but They Do Not" @AIatMeta found a weird failure mode in quantized reasoning models: ▪️ They don’t just get cheaper and less capable – they start overthinking. In up to 52% of failures, the model actually reaches the correct answer halfway through its reasoning... then talks itself out of it. It spirals into hesitation with "wait," "but," "maybe," and new branches. Why does this happen? Quantization mainly affects high-uncertainty decoding steps. It makes hesitation tokens much more likely to be sampled, sending the model into unnecessary self-reflection. → Meta proposed a very simple fix: apply a small decoding penalty to about 50 hesitation tokens. No retraining. Results: • 12–23% shorter Chain-of-Thoughts • Up to 58% fewer overthinking errors • Accuracy is often preserved (or even improved) across math, coding, and science benchmarks. So knowing when to stop is almost as important as knowing how to reason.
- 3Replies
- 9Reposts
- 29Likes
- 5.1KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 39
@burkov ·
Most reasoning systems built on LLMs scale by generating longer chains of intermediate text, one token at a time. A different family of methods, called recursive reasoning models, keeps a small internal state vector and repeatedly updates it using the same neural network weights, so the depth of reasoning comes from the number of update iterations rather than the length of generated output. Recent examples like HRM and TRM do well on hard puzzles such as Sudoku-Extreme and ARC-AGI, but for a given input they always perform the exact same sequence of updates and converge to a single answer, which is a poor fit for problems with many valid solutions, or where the first refinement path leads to a dead end. The authors of this paper modify the update rule so that at each iteration a small Gaussian perturbation, whose mean and variance the model learns to predict from the current state, is added to the hidden state, turning the deterministic recursion into a distribution over possible reasoning trajectories. On Sudoku, running 20 short stochastic trajectories in parallel matches or beats one very long deterministic trajectory at comparable compute, giving a "width" axis along which inference can be scaled in addition to depth, and the same architecture run with no input behaves as a generative model that produces valid 9×9 Sudoku boards from a blank grid 99% of the time, ahead of diffusion baselines that use roughly five times as many parameters and a thousand denoising steps. Read with an AI tutor and quizzes for better retention: https://t.co/HZgcw5Qe5V PDF: https://t.co/07CNJJtR87
- 5Replies
- 8Reposts
- 51Likes
- 2.9KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 40
@_vmlops ·
STANFORD JUST OPENED LECTURE 1 OF "SELF-IMPROVING AI AGENTS" TO THE PUBLIC... THIS IS THE COURSE FRONTIER LABS WISH THEY COULD TEACH INTERNALLY Taught by Aakanksha Chowdhery (ex-Google Brain/DeepMind) and Azalia Mirhoseini (ex-Anthropic, DeepMind, Google Brain) → "Large Language Monkeys": instead of asking a model once, sample thousands of outputs and use a verifier to pick the best one. models can solve problems this way that they fail in a single attempt → reasoning models like o1 improve simply by thinking longer at inference time no new parameters, just more compute → the key isn't longer chain-of-thought. it's learning when deep reasoning is actually worth the cost → coding agents like Claude Code and Codex became dramatically better because stronger base models + reinforcement learning with verifiable rewards created a compounding improvement loop → the biggest unsolved challenge is verification. math and code scale because answers can be checked automatically. open-ended tasks still rely heavily on human feedback
Watch video- 0Replies
- 0Reposts
- 11Likes
- 932Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 41
@alex_prompter ·
🚨 BREAKING: University of Tartu just quantified exactly how badly the AI industry is measuring model uncertainty. Eight samples of the wrong method. Millions in compute. Still worse than two samples combined correctly. The models know when they're guessing. The teams deploying them don't. > When you deploy a reasoning model in a high-stakes environment medical diagnosis, legal analysis, financial decisions you need to know when it's uncertain. The dominant approach is self-consistency: run the same prompt multiple times, check if the answers agree. The more agreement, the more confident the model is. Simple. Intuitive. Wrong. > University of Tartu tested this across three reasoning models, 17 tasks, and domains spanning mathematics, STEM, and humanities. Self-consistency starts substantially weaker than simply asking the model how confident it is and it never catches up. At two samples, self-consistency scores 70.5 AUROC in mathematics. Just asking the model its confidence at one > sample scores 71.3. You're running twice the compute to get worse results. The fix isn't more samples. It's the right combination at the minimum > sample count. Ask the model how confident it is. Check if two runs agree. Combine both signals with equal weight. Two samples with this hybrid approach scores 84.2 AUROC in mathematics beating eight samples of either method alone, which top out at 81.4 and 79.4 respectively. > Then the returns collapse. Going from two samples to eight with the hybrid method gains only 4.2 AUROC in mathematics and roughly 2 in other domains. The curve flattens almost immediately after sample two. Every additional chain-of-thought trace beyond that is paying full reasoning model cost for diminishing fractions of a point. → Self-consistency at K=2: 70.5 AUROC in mathematics → Verbalized confidence at K=1: 71.3 AUROC better, at half the cost → Two-sample hybrid: 84.2 AUROC beats eight samples of either method alone → Eight samples of verbalized confidence: 81.4 AUROC → Eight samples of self-consistency: 79.4 AUROC → Gains beyond K=2 with hybrid: approximately 2 AUROC across STEM and humanities The domain finding is the most alarming part for anyone deploying outside mathematics. In STEM and humanities the domains where medical, legal, and business AI actually operates uncertainty signals saturate faster, combine less effectively, and peak lower. The models are most calibrated in math because that's what RLVR training optimized for. Everything else is extrapolation from a narrower foundation than anyone admits. Two samples. Combined signal. That's the whole recipe.
- 5Replies
- 6Reposts
- 32Likes
- 7.5KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 42
@Marktechpost ·
Arcee AI just released Trinity Large Thinking, an Apache 2.0 open reasoning model built for long horizon agents, multi turn tool use, and structured outputs. Key specs: • 400B sparse MoE • 13B active params per token • 4-of-256 routing • 262k context on OpenRouter • #2 on PinchBench, behind Claude Opus 4.6 Full analysis: https://t.co/pBNXW0tqDN Technical details: https://t.co/Vw298MR3yg Model weight: https://t.co/fFoFEKhNBS @arcee_ai #AI #LLM #OpenSourceAI #Agents #MachineLearning
Watch video- 2Replies
- 7Reposts
- 13Likes
- 566Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 43
@pankajkumar_dev ·
Claude Opus 4.7 is officially here and its the massive leap we have been waiting for. - Opus 4.7 takes back the engineering lead 64.3% on SWE-bench Pro, up from 4.6 (53.4%) and ahead of GPT-5.4 (57.7%). - Hits 94.2% on GPQA Diamond basically matching top-tier models on complex reasoning. - Vision is massively upgraded 3× higher resolution (up to 2,576 px), much sharper for UI, slides, and technical content. - New xhigh effort level + task budgets (beta), better control over reasoning depth, latency, and cost in long runs. - /ultrareview in Claude Code runs multi-agent checks to catch subtle bugs and logic issues. - Visual reasoning jumps to 91.0% (CharXiv with tools), getting very close to restricted-tier models. - Auto mode now available for Max users long workflows run with far fewer interruptions. - Scores 54.7% on Humanity’s Last Exam with tools staying competitive with top reasoning models. Looks like 4.6 was just a temporary dip before this jump.
- 13Replies
- 3Reposts
- 28Likes
- 5.6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 44
@bibryam ·
Treat reasoning effort as a runtime policy: → choose from the request and tool state → cap it with time/token budgets → measure accuracy, latency, and cost → keep a user override @rasbt explains how effort modes are trained 😍 Controlling Reasoning Effort in LLMs😍 https://t.co/geVCBwzI9e
- 1Replies
- 4Reposts
- 11Likes
- 2.7KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 45
@doodlestein ·
Chain-of-thought reasoning traces were always problematic for alignment purposes. The fact that the Anthropic models were trained on them does make them even more useless, but they could be gamed anyway. People also constantly delude themselves through specious, performative, or self-serving reasoning (rationalization) for justifying their behavior. Often this process is verbalized to convince others about their internal decision-making. The only reliable approach here is to find a way to directly observe internal activation states, which is more like doing an fMRI scan of a human brain and much harder (if not impossible) for the model to fake. I detailed one possible method for doing this a year ago here: https://t.co/N0sNhoByMx
- 4Replies
- 2Reposts
- 29Likes
- 5.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 46
@RoundtableSpace ·
A developer benchmarked 10 LLMs on building 3D towers in a physics engine to test real-world spatial reasoning. The test places each model in a browser simulation to build the tallest stable structure using basic blocks. Frontier reasoning models successfully balance weight distribution, while lighter models stack top-heavy blocks that collapse instantly under gravity. Reddit link: https://t.co/H142C9wPcv
Watch video- 8Replies
- 1Reposts
- 57Likes
- 35.7KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 47
@rohanpaul_ai ·
Many assumed that once long-context models could reason, the old challenge of simply finding the right text was behind us. This paper shows that is wrong. Even strong reasoning models slip into a lazy habit of copying big chunks of the input into their own thinking, and the habit gets worse the longer the input is, quietly eating their token budget and dragging accuracy down. Copying itself is fine; the damage comes from copying the wrong stuff. Models that copy the few lines that actually matter tend to get the answer right, while models that copy the surrounding filler tend to get it wrong. They developed a simple reward that stops long-context language models from mindlessly copying their input, lifting accuracy by up to 4.6 points. The fix rewards the model for engaging with the small set of text that actually matters and penalizes it for copying the irrelevant filler around it. – arxiv. org/abs/2607.19345 Title: "Copy Less, Ground More: Overcoming Repetitive Copying in Long-Context Reasoning via Evidence-Aware Reinforcement Learning"
- 5Replies
- 2Reposts
- 10Likes
- 2.1KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 48
@mjamilmoughal ·
OpenAI reports that an internal version of its next model family, Astra, generated solutions to 10 long-standing open problems in mathematics and theoretical computer science (all open for at least a decade, some much longer). The results were published with a 249-page manuscript, model reasoning walkthroughs, and machine-checkable Lean 4 certificates (zero “sorry”s). Estimated inference cost for all ten: ~$2,000 at current Sol API rates. Astra itself remains unreleased. The claimed advances: -> High-dimensional sphere packing – new upper bounds approaching the Cohn–Elkies threshold (first general improvement since 1978) -> Binary and spherical codes – exponentially improved size bounds -> Non-sofic groups – first explicit construction (question open since Gromov 1999) -> Connes’s rigidity conjecture – disproved -> Arithmetic circuit complexity of the permanent – new lower bounds -> Quantum parallel repetition – new theorem for two-player quantum games -> Closest vector problem – stronger hardness-of-approximation results -> Ehrhart’s volume conjecture – proved in all dimensions -> Multicolor Ramsey numbers – resolution of Erdős problem 183 -> Extremal graph theory – resolution of Erdős problems 146 and 180 (compactness/degeneracy) These are serious claims in active research areas. The Lean formalizations are public on GitHub for independent verification. The mathematical community will now scrutinize the proofs and their significance. Paper: https://t.co/bdXxG2PNLe
- 1Replies
- 1Reposts
- 5Likes
- 3.5KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 49
@boyuan_chen ·
Calibration. Self-Distilled RLVR makes a sharp point: dense token-level signals are useful, but they should size the update, not decide the direction. The paper argues that on-policy self-distillation with privileged answers leaks information and becomes unstable over long runs. Their fix, RLSD, keeps RLVR in charge of update direction through verifiable environmental feedback, while self-distillation only adjusts update magnitude at the token level. That split feels right for reasoning RL. Correctness should anchor the objective. Dense teacher signal should accelerate optimization, not quietly replace the task. If you're training verifier-centric reasoning models, this is the cleaner design principle to keep: let the environment judge, let distillation calibrate. https://t.co/j2qE2hEoIl
- 0Replies
- 0Reposts
- 0Likes
- 114Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 50
@TejasKumar_ ·
i find reasoning effort to be a lie in ai high reasoning effort often provides worse results while using more reasoning/thinking tokens because llms get into a loop of self-doubt and eventually mess up their own context window and solve problems that no one asked for it's single player broken telephone
- 4Replies
- 0Reposts
- 12Likes
- 1.9KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post.
Best AI Reasoning Models tweets
Write posts like these, in your own voice
Xholic studies what works in your niche, drafts posts in your voice and schedules them for the hours your audience is online.
$0 today · Cancel anytime
Browse all tweet collectionsKeep exploring
From the blog
- The Best AI Twitter Reply ExtensionsBrowser extensions that draft X replies inline - speed, tone control, pricing and privacy compared. Including which ones read your timeline.
- 10 Top AI Tools for Creators in 2026Compare the top AI tools for creators in 2026 and learn how to build a focused creator stack around ideation, visuals, video, audio, repurposing, and X growth.
- AI Tweet GeneratorTurn a rough idea into a postable tweet - hooks, threads and CTAs. How AI tweet generators work, which to use, and the prompts that get results.
Free tools
More topics like this
- Best tweets about AI SearchExplore the best tweets about AI search, including AI Overviews, answer engines, citations, search behavior, traffic changes, and visibility strategy.
- Best tweets about Generative AIExplore the best tweets about generative AI, including models, products, business applications, research, creative tools, risks, and real-world results.
- Best tweets about OpenAIExplore the best tweets about OpenAI, from model and API releases to research, developer tools, and real-world applications. Updated every two weeks.
- Best tweets about Machine LearningFind the best tweets about machine learning, from models and datasets to training, evaluation, research papers, MLOps, and production systems.