Daily LLM 😍 Latest AI Models News
Joined November 2025
- Tweets612
- Following98
- Followers9
- Likes53
LLMBRICKS retweeted
🚀 DeepSeek-V4.1-Flash-1017 is here!
Stronger benchmark performance, faster task completion, and shorter outputs than the previous version—a Pareto improvement in performance and cost. Now live on our website, app, and API.
🛠️ Optimized for @DeepSeekHarness, Tencent CodeBuddy, WorkBuddy, and more. Upgrade to DeepSeek Harness v0.2.1-rc.1 or later for the best experience with the new model.
1/4
LLMBRICKS retweeted
AI coding agents are getting more powerful. But look at what has happened to their pricing.
In 2022, $10/month was enough to get started with a premium AI coding assistant.
In 2026, developers can spend $100–$200/month on a single coding agent.
That’s up to 20 TIMES the monthly spending.
Let’s look at the actual numbers. 👇
2022: The $10 era
GitHub Copilot launched its paid individual plan at $10/month.
Annual cost: $120.
AI helped you autocomplete code, suggest functions, and write repetitive logic.
2024: The $20 era
Cursor Pro was available for $20/month.
Annual cost: $240.
Compared with Copilot’s $10 benchmark, that’s 100% more expensive.
But developers were getting something different: AI-assisted editing, codebase context, and increasingly capable coding workflows.
2025: The $200 era
Cursor introduced Ultra at $200/month.
Claude offered Max tiers at $100 and $200/month.
Suddenly, the premium end of the coding-agent market looked very different.
Cursor’s new Ultra tier was 900% more expensive than its $20 Pro tier.
That’s $2,400 per year for one subscription.
2026: The usage-based era
GitHub Copilot introduced usage-based AI credits.
Its subscription tiers now include:
• Pro: $10/month
• Pro+: $39/month
• Max: $100/month
Cursor’s established coding plans include:
• Pro: $20/month
• Pro Plus: $60/month
• Ultra: $200/month
Claude Code offers:
• Pro: $20/month
• Max 5x: $100/month
• Max 20x: $200/month
And usage limits still apply.
Now look at the spending difference.
$10/month = $120/year
$20/month = $240/year
$100/month = $1,200/year
$200/month = $2,400/year
Going from a $20 plan to a $200 plan is a 900% increase in subscription spending.
But here’s the important distinction:
These aren’t necessarily price hikes on the same plan.
Companies are introducing higher tiers, more compute, and different usage allowances.
And that raises a bigger question.
Are coding agents becoming more expensive because AI is getting more capable?
Or are developers becoming increasingly dependent on tools whose usage costs are harder to predict?
A developer using AI for occasional autocomplete has very different needs from someone running autonomous agents for eight hours a day.
Higher pricing can make sense when it delivers substantially more value.
But the future of AI coding shouldn’t be accessible only to developers who can afford $200 every month.
In 2022, the conversation was about whether AI could write code.
In 2026, the conversation is about how much developers must pay to let AI keep writing code.
That’s a remarkable shift in just four years.
Where do you think coding-agent pricing goes next: cheaper access, more expensive subscriptions, or fully usage-based billing?
LLMBRICKS retweeted
"Stateless Language Agents: Scaling Long-Horizon Automated Research"
Long-running AI research agents waste tokens revisiting old ideas or repeating experiments.
Stateless Language Agents (SLA) instead store research progress externally, giving each agent a fresh, focused context while an Advisor coordinates experiments.
This setup outperforms competing frameworks on software engineering and optimization tasks, matching the strongest baseline on one kernel optimization task with 93% fewer tokens.
alphaxiv.org/abs/2610.07625
LLMBRICKS retweeted
.@SakanaAILabs and @berkeley_ai dropped something interesting for recursive self-improvement.
They proposed Multi-Agent Self-Supervision (MASS) - a method that tries to get more out of the model’s own feedback by having copies of it work as a team.
The agents share the same model weights but get different responsibilities, instructions, and contexts →
The idea is to optimize what each agent receives, produces, and passes on.
Here’s how it works:
▪️ MASS alternates between two loops.
1. The inner loop improves the workflow:
The model proposes a workflow, runs it, evaluates the results, and revises instructions, task assignments, and information routing. The weights stay unchanged.
2. The outer loop trains the model:
Optimized workflows generate trajectories: records of the agents’ conversations and actions. The shared model is fine-tuned on:
- Subagent trajectories: completing focused tasks
- Orchestrator trajectories: delegating, verifying, and integrating work
And as always, the results:
- 1.2–1.6× better score per token on four research benchmarks after two MASS cycles
- Evaluator accuracy: 73% → 93%
- 68.3% win rate vs. 64.0%, using fewer training tokens
- Slightly worse score per token on coding and terminal tasks
But the study showed only two rounds of improvement, not endless self-improvement.
But the study showed only two rounds of improvement yet, not endless self-improvement.
Either way, there’s an important insight here: a model really can improve by learning to split work across its copies and share results.
LLMBRICKS retweeted
Multi-Stream Attention Residuals
Multi-Stream Attention Residuals applies multi-head attention over network depth, achieving a 1.58x compute speedup over standard residuals at equal loss in tests on Mixture-of-Experts models up to 28B parameters.
arxivb.org/abs/2610.13630
LLMBRICKS retweeted
Introducing QwenGyre, bringing elastic RL to extreme-long-horizon (XLong) agent training. ✨
It launches with two core designs: 🥳
- Elastic Scheduler: reallocates GPUs between rollout & training as demand shifts—live executions never interrupted. Up to 1.85× speedup over Colocate, 1.78× over Async.
- Trajectory Processor: turns branching executions (compaction, sub-agents, retries) into prefix-shared trajectory trees with bounded, deduplicated training samples. Partial progress after timeout still gets scored.
Scaled to Qwen3.8-2.4T-A95B with ~700K tokens per rollout, QwenGyre lifts NL2RepoBench from 52.5% to 58.5% in 48 steps, cutting end-to-end training time by ~44% vs Async.
🔗 Read the paper:
arxiv.org/abs/2609.33848
LLMBRICKS retweeted
New paper from the team at Sakana AI:
Recursive Self-Improvement through Multi-Agent Self-Supervision (MASS)
How do we keep improving AI when the tasks become too complex for humans to reliably evaluate?
For open-ended research, we eventually hit a "supervision bottleneck." If we use the model itself as the solver, optimizer, and evaluator, it gets trapped in a homogeneous loop, reinforcing its own blind spots rather than correcting them.
To break this loop, we drew inspiration from Marvin Minsky’s Society of Mind. What if you prompt a single model to organize copies of itself into a structured team, then distill what the team learned back into the base model?
MASS alternates between two loops:
1/ Workflow Optimization: the model iteratively evolves its own multi-agent workflows, figuring out how subagents should communicate and route information to each other.
2/ Workflow Internalization: fine-tune the shared model on the successful multi-agent trajectories so the coordination behavior gets baked into the weights.
After two cycles with a 27B open-weights model, performance improved 1.2-1.6x per output token on tough research benchmarks (MLR-Bench, ScienceAgentBench, DSBench).
Multi-agent traces were also much better training data than single-agent ones. The model learns faster from jointly learning high-level orchestration and bounded subagent execution. The results showing that the model can bootstrap its own coordination skills by organizing copies of itself into teams feels promising as a mechanism towards self-improvement.
Blog: pub.sakana.ai/mass/
Paper: arxiv.org/abs/2610.12176
Incredible work by Hyunin Lee, Jinglue Xu, Jeffrey Seely, Yujin Tang, and our collaborators from UC Berkeley (Somayeh Sojoudi, Matei Zaharia, Donghyun Lee)!
Introducing Multi-Agent Self-Supervision (MASS): Recursive self-improvement through collective intelligence
Blog: pub.sakana.ai/mass/
As AI systems tackle increasingly open-ended research problems, human experts may struggle to assess results and guide further progress. The model itself may be the best available optimizer and evaluator. The challenge is obtaining useful self-supervision within that homogeneous loop, where a model risks reinforcing its own blind spots rather than correcting them.
We ask whether a model can learn from the collective intelligence of its own team.
We introduce Multi-Agent Self-Supervision (MASS). One shared model solves tasks through a team of virtual subagents, searches for better multi-agent workflows, then uses its own judgments to select the best ones.
Training on the best team’s executions provides self-supervision by distilling the team’s collective experience into the shared model.
We ran two cycles using a 27B open-weights model on synthetic open-ended research tasks. After the second cycle, score per output token reached 1.2-1.6x the base model's level across four research benchmarks.
Three key results:
First, MASS enables role generalization within an RSI loop: training only on task-solving data from the optimizee naturally improves the capabilities of both the optimizer and the evaluator.
Second, multi-agent trajectories are more efficient training data than single-agent trajectories for RSI.
Third, optimizer capacity, rather than evaluator capacity, can be the bottleneck in the speed of improvement.
We believe the community needs to investigate homogeneous RSI carefully to support AI safety. When a model is also its own evaluator, shared blind spots could allow mistakes to be accepted as progress and reinforced through training. For AI to improve beyond human expertise safely, we need to understand these failures and preserve effective ways to detect them and intervene.
Paper: arxiv.org/abs/2610.12176
Code: github.com/SakanaAI/mass
This work was a collaboration with researchers at UC Berkeley.
LLMBRICKS retweeted
I noticed something funny.
Whenever a coding agent is working, developers are doing one thing 100% of the time — watching reels on their phones. 😂
So we built Wave Code around that behavior.
Your coding agent works on your laptop.
You watch ads on your mobile.
The agent keeps coding.
Why pay a monthly subscription when your attention can power the agent? 🚀
LLMBRICKS retweeted
Deepseek V4.1 Flash 552B total, 8/16B active with a new arch trained on 45T tokens, there are different active parameters for input/output tokens with the encoder/decoder arch, engram, new sparse attention, new mHC, native vision
very high benchmarks (beating K3), insane efficiency, and as always amazing tech report
this is probably the most novel arch i've seen in a while, pretty insane
LLMBRICKS retweeted
“Don't Drop Dropout: Optimizing Layer Sparsity for Efficient LLM Training and Inference”
Layer dropout mostly disappeared from modern LLM pretraining because it was thought to hurt accuracy at scale.
But this Cerebras paper shows the opposite when configured correctly.
They apply layer dropout at the whole Transformer-block level, sampled per sequence, use an increasing dropout distribution across depth, and a decreasing dropout schedule over training that decays to zero.
Across 2,400 runs up to 8.2B parameters, this saves up to 25% of training FLOPs while preserving accuracy, and makes models depth-elastic enough for early exit, layer skipping, and up to 1.55x faster self-speculative decoding.
alphaxiv.org/abs/2609.05275
LLMBRICKS retweeted
well folks if you are interesting in understanding how to generate synthetic pretraining data I got a nicely edited 1h30 min tutorial with @joelniklaus from huggingface/nvidia just for you
in it we go through the result of their 90 experiments and contemplate what it means frfr
LLMBRICKS retweeted
Chinese researchers did it again!
Moonshot AI proved that 95% of attention computation is completely wasted..
They’ve open-sourced the exact attention mechanism powering Kimi's long context.. and it's 16x faster.
It’s called MoBA (Mixture of Block Attention).
Every time you feed an AI a massive prompt, every token desperately tries to look at every single token that came before it.
The math scales quadratically ($O(N^2)$).
It’s like reading a 500-page book and re-reading the entire thing from word one every single time you want to understand a new sentence.
Moonshot looked at this waste and said: No.
Instead of forcing full, brute-force attention across everything, MoBA applies the principles of Mixture of Experts (MoE) directly to the attention layer.
How it works:
• It chops the context history into discrete blocks.
• A lightweight dynamic gating mechanism lets each query token instantly "vote" and route only to the specific blocks that actually matter.
• It achieves up to 95% sparsity on long contexts without sacrificing performance.
The results are staggering:
It maintains full-attention accuracy on 1-million-token contexts while slashing massive compute overhead.
We are watching the structural efficiency barrier of long-context AI get smashed in real-time.
While Western labs argue about how to afford million-token context windows, Moonshot open-sourced the blueprint to make them radically cheap.
LLMBRICKS retweeted
🚀 Meet MiniCPM5-2B, a 2B-parameter language model bringing high intelligence density to the edge, now open source!
It ranks #1 among open-source models under 4B parameters on the
@ArtificialAnlys Intelligence Index, with a score of 23.
It also scores 20 on the Agentic Index, bringing an early form of general-purpose agent capability to the edge.
Across 34 benchmarks, MiniCPM5-2B achieves an average score of 53.9, covering coding, math, long-context understanding, tool use, and agentic tasks.
And this release goes beyond the model itself.
We’re opening up the data, training recipes, and RL stack behind MiniCPM5-2B.
🤗 Hugging Face: huggingface.co/openbmb/MiniC…
💻 GitHub: github.com/OpenBMB/MiniCPM
Modelscope: modelscope.cn/models/OpenBMB…
Web: openbmb.cn/
LLMBRICKS retweeted
RoPE都被NoPE淘汰了，那条64维分支居然被训练成了模型自己的重要性便签？
arxiv.org/abs/2609.03949
VestigeKV发现，Kimi Linear的MLA缓存里这分支不再编码位置，而是携带查询无关的显著度。用它给缓存行打分：top-m保留，其余移到可检索的archive而非删除。不训练不量化不改内核，只读每行约11%的维度。8k-65k上下文8x压缩retrieval保持1.00，32x 0.92；同一招放到RoPE MLA上立刻崩坏，似乎RoPE下本就不存在这种查询无关信号。
LLMBRICKS retweeted
Next Latent Prediction is a really interesting paper, and this collection is a great way to actually understand how it works.
It takes you through the topic in three stages:
- Math problems to build the mathematical foundation
- NumPy problems to understand the core concepts from scratch
- PyTorch project to implement the full idea in practice
Reading a paper can help you understand the idea, but the best way to truly understand it is to implement it yourself
well folks this weekend I’m going to learn about next-latent prediction transformers and how this training pressure help them converge towards belief-states
hella cool method and good news I’ll also be interviewing the first author @jayden_teoh_ next week!!!
LLMBRICKS retweeted
This paper from Tencent tackles one of the most annoying hurdle of Self-Guidance Collapse in Reasoning LLMs.
Usually if we rely strictly on verifiers (RLVR), the signal is way too sparse across long chains of thought.
But if we let the model densely guide itself, it inevitably hallucinates false confidence and collapses into a single repetitive strategy.
The authors propose "FlowBalance," and the mechanism is super clever.
They use a frozen training-time view of the policy to provide dense feedback, but tie it directly to group advantage from the verifier.
For positive advantage, keep the guidance.
For Negative, flip the guidance in reverse.
For no preference in the rollout, shut it off entirely so it stops hallucinating phantom signals.
They train the whole target distribution via trajectory balance rather than token-level imitation.
And the empirical gains on Qwen3-4B/8B look genuinely solid. It shows faster convergence, no length collapse, and noticeably better solution diversity on AIME24.
Definitely worth a read if you work on On-Policy RL & Reasoning: arxiv.org/pdf/2609.03241
LLMBRICKS retweeted
The Top AI Papers of the Week (Aug 31 - Sep 6):
- CORAL
- WikiSkill
- SKILL.state
- E-Commerce Bench
- Declarative Attention
- Harness-of-Harness
- AI Research Preference Models
Read on for more: xitter.cf/dair_ai/status/2096617…
LLMBRICKS retweeted
// Normalized Low-Rank Adaptation (NoRA) //
They propose a one-line change to LoRA that costs nothing and improves convergence, stability and forgetting.
LoRA initializes the up-projection to zero, which means early optimization is governed almost entirely by the down-projection. This observation tells you where to regularize.
NoRA normalizes the down-projection matrices during training. The authors also show the same normalization applied once at initialization improves standard LoRA without repeating it through training, which is the cheaper of the two options.
The benefits hold across pretraining, supervised fine-tuning and reinforcement learning. Faster convergence, better final performance, more stable training, and less catastrophic forgetting.
It adds no trainable parameters and no inference-time computation, which is what makes it broadly applicable rather than another specialized LoRA variant.
Paper: academy.dair.ai/papers/norma…
