On X – we follow important research papers and explain ideas behind it. In the newsletter, we connect the dots between AI’s past, present, and future ⬇️
I had a couple of weeks before launch to play with Astra 6.2 and 6.2 Sol. They became much better in the last few days before release.
And I would choose Astra 6.2 over Fable for sheer speed and token efficiency. It's just faster and doesn't drain your credits.
At this point, when all the models are extremely good, the interface – and clarity around what to choose and how to use it – becomes crucial.
With all this raw intelligence, we need to dumb down how users actually choose and operate these models.
One of the funny reasons for the difference in vibes between the influencers and the crowd today on 6.2 Sol/Astra is that we gave a few folks access a while ago and then made a lot of changes in the last 3-4 days and I'm pretty sure no re-testing was done within those days and the videos were produced last week.
Don't get me wrong, while the models are a hefty jump compared to their GPT predecessors, they are by no means perfect and there are a few things the teams are excited for the models to get better at in future iterations in terms of taste and niceness of use. Love all the feedback and we hear you!
8 models graded 620 anonymized medical answers. Every one of them ranked its own answer higher than the other 7 judges did. About 1.2 places on average, almost 3 for GPT-5.6 Sol. Telling them which model wrote which answer barely changed it.
A lot of the leaderboards we read every week use a single LLM judge. How many of those results would hold up with a judge from a different model family?
x.com/rohanpaul_ai/status/21…
New Stanford paper finds that all 8 LLMs tested rank their own medical answers higher than other models rank them, even when answers are anonymous.
Medical AI benchmarks often use LLMs to grade other LLMs' answers. If a judge favors its own outputs, the benchmark tilts toward that model.
They had 8 models from OpenAI, Anthropic, Google and Qwen answer 620 real clinician questions, then rank all 8 anonymous answers. They compared where each judge placed its own answer with where the other 7 judges placed that same answer.
Every judge favored its own answer, by 1.22 rank positions on average and nearly 3 for GPT-5.6 Sol. The bias held without a rubric, and revealing model names cut it by only 0.094 positions.
If you use LLM judges, use a panel from several model families and report results per judge instead of 1 pooled score.
The race to real-time, long-horizon AI video is somehow a race of "forcing" methods right now.
The 15+ approaches you need to know:
▪️ Diffusion Forcing + DFoT
▪️ Self Forcing
▪️ Rolling Forcing
▪️ Self-Forcing++
▪️ Deep Forcing
▪️ Causal Forcing
▪️ Сontext Forcing
▪️ Hybrid Forcing
▪️ Any Forcing
▪️ Wave Forcing
▪️ Trajectory Forcing
▪️ Relax Forcing
▪️ One-Forcing
▪️ Disen-Forcing
▪️ Causal Forcing++
Some fix imperfect frames, others manage memory or parallelize denoising across GPUs.
Here’s our quick + comparison table to tell them apart (with links to all papers and code):turingpost.com/p/15-forcing-…
Must-read papers of the week
▪️ World In-Context Learning for Agentic Robot Manipulation
▪️ Don’t Just Trust Your Memory
▪️ Is Your Robot’s Memory Just a Clock? Temporal Shortcuts in Memory-Augmented VLA Policies
▪️ Unbundling Multimodal Vision Encoding
▪️ V-JEPA-LM
▪️ Learning Heterogeneous Tactile Representation for General Dexterous Manipulation
▪️ Training Reasoning Models in Simulation to Natively Use Real Robots
▪️ Embodied First Exam
▪️ Continual-ARC: Measuring Skill Acquisition over a Working Lifetime
▪️ Reframe: Observation-Aligned Multi-Teacher On-Policy Distillation for Agentic Visual Reasoning
▪️ MemInStream: Memorizing or Merely Recognizing? Rethinking Streaming Video Memory Evaluation
▪️ Infrathon: Benchmarking Language Agents for Real-World, Long-Horizon AI Infra Optimization
▪️ Actor, Judge, or Teacher? Understanding Decision Models in Long-Horizon Agents
▪️ GTAGym: AAA Game Tasks Environment for Evaluation and Reinforcement Learning
Explore these to keep up with main AI trends. Here’s also the full list of outstanding papers + links, and our weekly AI news digest: turingpost.com/p/who-are-we-…
Lots of self-improving agent papers this week. A good chunk of the gains turn out to be agents getting better at the benchmark, not the task. So we put the papers that actually check first.
1. Beneath the Surface: What We Overlook When We Talk About Agent Evolution
Evolving the harness can lift benchmark scores with no weight updates, but the gains are unreliable, expensive and transfer poorly. Read this one first.
arxiv.org/abs/2611.07624
2. Learning the Task or Learning the Verifier?
Show a self-improving embodied coding agent the benchmark's success criteria and its score goes up. Its actual task completion doesn't.
arxiv.org/abs/2611.08318
3. Evidence-Governed Adoption of Self-Generated Updates in Autonomous AI Agents
Separates "the agent wrote a change" from "the agent ships it". Every change has to pass fresh paired audits and a non-inferiority check first.
arxiv.org/abs/2611.16378
4. Harness^2: Recursive Agent Harnessing for an Open World
A harness that improves itself on new tasks without an answer key, by test-running edits and keeping what helps.
arxiv.org/abs/2610.14224
5. Experience-Handoff Reinforcement Learning for Recursive Self-Improvement
Agents trained with RL learn to write and curate notes for their future runs, not only to pick better actions.
arxiv.org/abs/2611.16409
6. InfraRSI: Harnessing Recursive Self-Improvement for Training Infrastructure
Self-improvement where it's hardest: distributed training, where one bad edit means an OOM or silent numerical drift. Every optimization gets verified.
arxiv.org/abs/2611.11558
7. Incentivizing Self-Learning in Large Language Models via Reinforcement Learning
Give a model long reference material and train it to look things up and study while it solves the problem, instead of relying on what it already knows.
arxiv.org/abs/2610.39671
8. PhysLoop: Harnessing LLMs' Physics Awareness for Self-Improving Video Generation Models
An LLM spots physics mistakes in generated videos and guides the fixes, so the video model improves on cleaner data.
arxiv.org/abs/2611.16748
9. A Cross-Scenario Survey and Analysis of Self-Evolving Multimodal Agents
Why a self-improvement trick that works for reasoning often breaks for navigation or manipulation. A good map of the field.
arxiv.org/abs/2611.14256
If you're letting an agent edit its own setup: who decides which edits stay? Tests, a human, another model?
Yes, please. Every new open model = rewriting the same attention block with a slightly different twist. LEGO for LLMs, or something like this?
@rasbt is onto something
The open-source LLM ecosystem could really benefit from an LLM building-block API.
We have so many LLM components across different models now. Whether you are using PyTorch or C++ and CUDA code directly, there is a major switching cost when you want to run experiments or ablation studies, say swapping GQA with MLA, dense FFNs with MoE, attention layers with Mamba2 or Gated DeltaNet, or standard residual connections with attention residuals.
Currently, it’s very messy even with LLM-assisted coding.
It could maybe be on top of PyTorch or CUDA directly, but it needs to be carefully engineered and maintained (versus quickly vibe-coded on a weekend) and efficient enough that people trust it to use in production (which is really a requirement to move beyond toy examples).
Maybe some food for thought for a big, well-funded lab :)
(There are some efforts that go into that direction, like torchtitan, torchtune, Megatron Core, OLMo-core, but they are not quite that level of abstraction, I'd say.
And, as always, there’s the chicken-and-egg problem: it needs to be popular to get widely adopted, and it needs to get widely adopted to become popular.)
Looped Transformers are low-key fascinating. First of all, you need to understand what travels around the loop and the 3 core things you set for the architecture.
A Looped Transformer runs the same Transformer block (or stack) for multiple passes, feeding each output back in as the next input.
▪️ What travels around this loop is the hidden state:
- Token embeddings form the initial hidden representation.
- The shared stack updates that representation via attention and feed-forward operations.
- Its output goes back to the stack for another pass, using an updated hidden state. Some designs also reuse the input, add time-step embeddings, or run multiple residual streams.
- After the chosen number of passes, the output head converts the selected representation into token scores.
That's all to win additional computation without an additional set of block weights for every pass.
Although the weights stay the same during inference, changing inputs let the same block produce different updates. During decoding it attends via the KV cache, during prefill it updates masked tokens in parallel.
A model can loop its entire stack or repeat only a middle stack between ordinary input and output blocks.
Note that repeating the stack doesn't require generating a new text token between passes.
▪️ So there are 3 basic things you need to identify for the specific Looped Transformer architecture:
1. The repeated blocks
2. The state they receive
3. The rule that controls their execution - a fixed number of passes, a user-selected count, or an adaptive rule
If you want to nerd out on the rest, like adaptive depth, what happens to the KV-cache and hardware, 2026 breakthroughs, and when another pass is worth the cost - we put together a full guide over here: turingpost.com/p/looped-tran…
AI routing is like an art of its own ↓
Which model, tool, or policy should handle your request is a job of a router.
AI router can be a set of rules, a classifier, a small neural network, or another language model.
Its decision can work in a few ways:
- Route by task type: e.g., send coding requests to a coding model. But simple, a one-line edit and a difficult bug don’t need the same resources.
- Predict how each candidate will perform on the specific input, using data from previous runs.
- Weigh that predicted quality against cost. The more cost matters, the bigger the quality advantage an expensive model needs to justify its selection.
▪️ But there are some pitfalls on the routing road.
- Choosing the most likely winner isn’t the same as choosing the best expected result. One model may win often but also crash hard. Another may rarely come first but stays consistently strong, or is strong for the specific start.
- The savings aren’t always worth it: a model may cost one-tenth as much as a perfect model but succeeds only 15% of the time. It produces 50% more correct answers per dollar, but it also fails 85% of the time.
That's why a router may need a quality floor: a minimum level of performance it has to maintain while trying to reduce cost.
@YangYou1991, great work on Route Anything!
@RoyRinberg, great work on FlashProve!
We’ve covered the rest of the details and challenges of routing here, plus how FlashProve and VeriRouter can help verify router's choice and results: turingpost.com/p/routing-who…
As I’ve said for years, concentration of power, capabilities and wealth is the biggest risk in AI. The natural tendencies for it are super strong and without much much stronger open-source, we might end up in a world with more asymmetry and inequalities than ever!
Anthropic’s IPO could make about 4,250 of its 5,300 employees millionaires, per an analysis by financial platform Hill, including roughly 50 worth more than $100 million each.
The estimate assumes a $1.5 trillion valuation, above the roughly $1 trillion Anthropic is now targeting.
.@zep_ai introduced Zep Agent Skills, and it’s really worth your attention.
It's a procedural memory system that turns verified, successful AI agent runs into reusable Skills.
The idea of procedural memory isn't new, but Zep is trying to turn it into a managed service, with a few technically interesting details ↓
First, here's how it works:
1. Tracing: Zep records the agent's actions, tool calls, and outcomes as a Trace. It can also import Traces from Braintrust and LangSmith.
2. Verification: Checks whether the task actually succeeded using independent evidence, not just the agent's claims.
3. Compilation: A Reflector proposes reusable instructions, while a Curator checks them against the evidence. Each Skill field links back to specific Trace events.
4. Admission: Safety is a very important point. Security scans and quality gates determine whether a new Skill version becomes available.
5. Retrieval: Agents find relevant Skills through lexical search, load instructions when needed, and record outcomes that influence future rankings.
Then, there are a few features that are particularly interesting and make Zep's system distinct:
• Skills aren't tied to one model. A stronger model can solve a task once, and a weaker model can reuse the procedure without retraining.
• Zep uses the open Agent Skills format. Each Skill is packaged as a SKILL.md file with YAML frontmatter and optional files, so compatible harnesses like Claude Code and Codex can load it.
• Every Skill field needs evidence. The compiler links instructions to specific Trace events, making it possible to inspect where they came from. It can also patch individual fields instead of rewriting the whole Skill.
• Skills have a lifecycle. They’re versioned, checked before activation, and ranked partly by verified outcomes. A Skill can even start from one verified success, but remains provisional until it gathers more evidence.
The results are also fascinating:
- Skills learned from Opus 5.5 improved three weaker models' pass rates on the same tasks by 4.5–18.8 percentage points across 3 benchmarks.
- On EnterpriseOps-Gym, all three weaker models using Skills at low reasoning effort beat max effort without them.
Most gains came from tasks the stronger model had already solved.
Try Zep Agent Skills yourself here, you may find something interesting: getzep.com/zep-agent-skills/…