Laurentiu Meirosu

AI research engineer working on alignment & safe AI @SyntelesisLab | Ex @Google

[Joscha Bach @Plinz]

Computers are systems that create worlds that are independent of the physical universe. Computers can create any universe that emerges over laws that can be fully specified in a constructive language. Computers can be built in physics and inside of other computers.

[Robert Youssef @rryssf]

Stanford and Caltech researchers just published the first comprehensive taxonomy of how llms fail at reasoning

not a list of cherry-picked gotchas. a 2-axis framework that finally lets you compare failure modes across tasks instead of treating each one as a random anecdote

the findings are uncomfortable

[Xin Eric Wang @xwang_lk]

Introducing 𝐆𝐫𝐨𝐮𝐩-𝐄𝐯𝐨𝐥𝐯𝐢𝐧𝐠 𝐀𝐠𝐞𝐧𝐭𝐬 (𝐆𝐄𝐀), a new paradigm for open-ended self-improvement in AI agents.

The core shift is simple but radical:
👉 𝐭𝐡𝐞 𝐮𝐧𝐢𝐭 𝐨𝐟 𝐞𝐯𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐢𝐬 𝐧𝐨 𝐥𝐨𝐧𝐠𝐞𝐫 𝐚 𝐬𝐢𝐧𝐠𝐥𝐞 𝐚𝐠𝐞𝐧𝐭, 𝐛𝐮𝐭 𝐚 𝐠𝐫𝐨𝐮𝐩 𝐨𝐟 𝐚𝐠𝐞𝐧𝐭𝐬.

Why does this matter?
To answer that, we need to rewind.

Scientific breakthroughs share two core traits: open-endedness and cumulative progress.

Exploration never truly ends, and crucially, discoveries don’t vanish: they accumulate, compound, and unlock future advances.

AI progress should work the same way.
But today, it mostly doesn’t.

Most AI systems are built on fixed, human-designed architectures.

They can train.
They can optimize.
They can accumulate experience.

But they rarely escape the structural limits imposed at design time.

They cannot meaningfully reconfigure themselves, so progress remains bottlenecked by continuous human intervention.

To fix this, researchers turned to open-ended self-improving systems, often inspired by biological evolution.

The dominant pattern looks like this:
- select one parent agent
- refine it
- produce offspring
- repeat

Evolution unfolds as a chain or tree.

This sounds powerful, and it is good at generating diversity.

But there’s a hidden flaw.

Those evolutionary branches are isolated.

Agents explore independently, discoveries stay local, and most variants are short-lived. They add novelty, but rarely become stepping stones for long-term progress.

Exploration happens.
Accumulation doesn’t.

This leads to an uncomfortable question:
Why are we forcing AI agents to evolve like biological individuals?

AI agents aren’t constrained by reproduction, lineage, or genetics. They can directly share:
- trajectories
- tools
- workflows
- learned artifacts

They can aggregate complementary skills instantly.

So why not design evolution around that?

This is where Group-Evolving Agents (GEA) comes in.

GEA rethinks evolution from the ground up by treating a group of agents as the fundamental evolving entity.

Not a single parent.
Not isolated branches.

A collaborative, experience-sharing group.

Here’s how GEA works at a high level:

1️⃣ Parent Group Selection
At each iteration, GEA selects a parent group using a Performance–Novelty criterion — balancing strong performance with exploratory diversity.

2️⃣ Experience Aggregation
Instead of isolating agents, all members contribute their experiences into a shared pool.

3️⃣ Group Reproduction
Using this pooled experience, the parent group jointly produces a child group.

Exploration is no longer wasted — it’s consolidated.

This one change fixes a core failure mode of prior systems.

In classic tree-structured evolution:
- diversity explodes
- but useful discoveries die on isolated branches

In GEA:
- diversity is explicitly reused
- progress becomes cumulative
- improvements persist across generations

When evaluated on challenging coding benchmarks, the impact is clear:
- 71.0% success on SWE-bench Verified
- 88.3% on Polyglot
- This significantly outperforms prior SOTA self-evolving methods (56.7% and 68.3%).

But the more interesting part is why.

Analysis shows GEA:
- consolidates exploratory diversity instead of losing
it
- achieves stronger performance with the same number of agents
- is more robust to framework-level perturbations
- improves workflows and tools rather than overfitting to a specific model

These gains transfer consistently across GPT- and Claude-series models.

GEA performs meta-learning-based self-improvement with no human intervention.

And yet it:
- matches human-designed SOTA on SWE-bench Verified (years of efforts from our top AI researchers)
- vastly surpasses it on Polyglot

All through open-ended, group-level evolution.

The takeaway:
Open-ended progress doesn’t fail because exploration is hard.

It fails because discoveries don’t accumulate.

By evolving groups instead of individuals, and enabling explicit experience sharing, GEA turns exploration into something that finally compounds.

That’s the promise of Group-Evolving Agents.

[Fazl Barez @FazlBarez]

🚀New paper: "Chain-of-Thought Hijacking"!

We found a universal jailbreak in Reasoning Models and worked with frontier labs to fix them!

Our attack achieves >94% attack success rate against ALL leading proprietary models.🤯
1/7

[Max Kleiman-Weiner @maxhkw]

New paper challenges how we think about Theory of Mind. What if we model others as executing simple behavioral scripts rather than reasoning about complex mental states? ROTE (Representing Others' Trajectories as Executables) treats behavior prediction as program synthesis.

[Rohan Paul @rohanpaul_ai]

New @Microsoft paper teaches LLMs to organize reasoning into concurrent subtasks for faster, more accurate answers.

It shows 28% lower wait time than typical parallel thinking while also boosting math accuracy.

The big deal is simple, it turns coordination into a skill the model learns, so it decides when to split work, when to wait, and when to merge.

The usual single chain wastes time because each step blocks the next.

Fixed parallel plans also waste time because they cannot adapt to each query.

The fix is an organizer that writes simple Fork and Join tags to start and merge worker thoughts.

Workers chase sub-queries in parallel while the organizer keeps thinking and only pauses to Join.

All control lives in plain text, so the base model stays unchanged.

Training happens in 2 stages, first supervised traces that teach the tag format.

Then reinforcement learning rewards correct final answers, clean format, and real concurrency.

Speed is measured by the critical path through the Fork-Join graph, which matches true waiting.

Across countdown puzzles, math questions, and Sudoku, the learned policy runs faster and fails less.

The big idea is to learn organization itself rather than hard-code a script.

----

Paper – arxiv. org/abs/2510.26658

Paper Title: "The Era of Agentic Organization: Learning to Organize with Language Models"

[Ahmed Karim @ahmedkar_]

LLM hallucinations aren't bugs.
They're predictable compression failures. Now we can measure the bits needed to prevent them before generation.

Preprint + toolkit 👇

[Wes Gurnee @wesg52]

New paper! We reverse engineered the mechanisms underlying Claude Haiku’s ability to perform a simple “perceptual” task. We discover beautiful feature families and manifolds, clean geometric transformations, and distributed attention algorithms!

[Jack Lindsey @Jack_W_Lindsey]

We’re releasing an open-source library and public interactive interface for tracing the internal “thoughts” of a language model. Now anyone can explore the inner workings of LLMs — and it only takes seconds!

[Jack Lindsey @Jack_W_Lindsey]

Prior to the release of Claude Sonnet 4.5, we conducted a white-box audit of the model, applying interpretability techniques to “read the model’s mind” in order to validate its reliability and alignment. This was the first such audit on a frontier LLM, to our knowledge. (1/15)

[Max Kleiman-Weiner @maxhkw]

Our new paper is out in PNAS: "Evolving general cooperation with a Bayesian theory of mind"!

Humans are the ultimate cooperators. We coordinate on a scale and scope no other species (nor AI) can match. What makes this possible? 🧵

[Jinyeop Song @jinyeop_song]

#1. New paper alert!🚀

How do we evaluate LM agents today? Mostly benchmarks. But: (1) good benchmarks are costly + labor-intensive, and (2) they target narrow end goals, missing unintended capabilities.

In our recent paper, we propose a goal-agnostic alternative for evaluating LM agents that uses empowerment as the core metric for agentic capability.

[Kunal Jha @kjha02]

Forget modeling every belief and goal! What if we represented people as following simple scripts instead (i.e "cross the crosswalk")?

Our new paper shows AI which models others’ minds as Python code 💻 can quickly and accurately predict human behavior!

https://t.co/1t2fsW7jyL🧵

[Badr AlKhamissi @bkhmsi]

🚀 Excited to share a major update to our “Mixture of Cognitive Reasoners” (MiCRo) paper!

We ask: What benefits can we unlock by designing language models whose inner structure mirrors the brain’s functional specialization?

More below 🧠👇
https://t.co/LVBLQ9yFlA

[Andrej Karpathy @karpathy]

In era of pretraining, what mattered was internet text. You'd primarily want a large, diverse, high quality collection of internet documents to learn from.

In era of supervised finetuning, it was conversations. Contract workers are hired to create answers for questions, a bit like what you'd see on Stack Overflow / Quora, or etc., but geared towards LLM use cases.

Neither of the two above are going away (imo), but in this era of reinforcement learning, it is now environments. Unlike the above, they give the LLM an opportunity to actually interact - take actions, see outcomes, etc. This means you can hope to do a lot better than statistical expert imitation. And they can be used both for model training and evaluation. But just like before, the core problem now is needing a large, diverse, high quality set of environments, as exercises for the LLM to practice against.

In some ways, I'm reminded of OpenAI's very first project (gym), which was exactly a framework hoping to build a large collection of environments in the same schema, but this was way before LLMs. So the environments were simple academic control tasks of the time, like cartpole, ATARI, etc. The @PrimeIntellect environments hub (and the `verifiers` repo on GitHub) builds the modernized version specifically targeting LLMs, and it's a great effort/idea. I pitched that someone build something like it earlier this year:
https://t.co/ANHhasxzD8
Environments have the property that once the skeleton of the framework is in place, in principle the community / industry can parallelize across many different domains, which is exciting.

Final thought - personally and long-term, I am bullish on environments and agentic interactions but I am bearish on reinforcement learning specifically. I think that reward functions are super sus, and I think humans don't use RL to learn (maybe they do for some motor tasks etc, but not intellectual problem solving tasks). Humans use different learning paradigms that are significantly more powerful and sample efficient and that haven't been properly invented and scaled yet, though early sketches and ideas exist (as just one example, the idea of "system prompt learning", moving the update to tokens/contexts not weights and optionally distilling to weights as a separate process a bit like sleep does).

[Anirudh Goyal @anirudhg9119]

We mine "how to" reasoning from solving lots of math problems into a shared procedural memory (behavior handbook). It's like providing a model shared workspace to write to and read from.

At test time, we read this memory in context for self-improvement.

[Lakshya A Agrawal @LakshyAAAgrawal]

Paper: https://t.co/zJAbPor4w5

GEPA will be open-sourced soon as a new DSPy optimizer. Stay tuned!

Incredibly grateful to the wonderful team @ShangyinT @dilarafsoylu @NoahZiems @rishiskhare @kristahopsalong @arnav_thebigman @krypticmouse @michaelryan207 @Meng_CS @ChrisGPotts @koushik77 @AlexGDimakis @istoica05, Dan Klein, @matei_zaharia @lateinteraction

[Omar Khattab @lateinteraction]

The core principle of DSPy is to ask humans to specify intent ONLY in the most natural shape *each* intent takes.

Maximalists of RL—and prompt optimization—get this wrong. They think the bitter lesson means data, experience, rewards win all.

But often, the human designer knows (and fully intends!) an abstract rule, either as code structure or natural language spec, rather than something driven by data.

Asking them to collect data (or build environments) misses the point here.

DSPy’s core principle is to be maximally declarative. In essence, we claimed in 2022 that this *has* to involve, in the general case, THREE different shapes of abstraction:

1) Control flow and code structure for formal, hard rules. Aka Modules.

2) Structured natural language declarations for fuzzy specifications, focusing on the what, not the how. Aka Signatures.

3) Data and metrics for learning (PO or RL), for the long tail of exceptions, edge cases, and model-specific hacks or interactions. Aka Optimizers.

That’s it. This is a statement about the natural form intents take.

You try to coerce AI systems into just one of these three (RL maximalists, vibe prompt maximalists, or symbolic AI) and you’ll fail in the general case before you start because the challenge isn’t an engineering one at that point yet, it’s just bad intake for problem specifications.

[Laurentiu Meirosu @LMeirosu]

A 3D-printed deep neural network that operates at the speed of light:
"All-optical machine learning using diffractive deep neural networks" https://t.co/TiEWrc4QPo

[Google AI @GoogleAI]

Check out the open source release of DeepLab-v3+, our latest and best performing semantic image segmentation model, implemented in #Tensorflow. https://t.co/tslaEHxCPY