agentic LCA

agentic AI and Hybrid intelligent systems for quantitative sustainable assessments

[Epoch AI @EpochAIResearch]

GPT-6 Astra has set a new ECI record, with a score of 169. This is a substantial jump from the prior best (163), but is within our uncertainty range for the reasoning-era ECI trend. Astra also set new records on our math, continual learning, and game-puzzles benchmarks. On our long-horizon coding benchmark, MirrorCode, Astra ranks between Opus 4.7 and Fable 5.

OpenAI gave us pre-release access to test Astra. Charts and more details for Astra’s individual benchmark results in the thread.

[Jason Abaluck @Jabaluck]

The most powerful chess engines work by training a value function to evaluate positions and then doing an extensive, highly optimized tree search, calculating a vast number of possible lines.

A 2024 paper (link below) showed that chess engines can reach grandmaster strength simply by distilling the judgments of a strong chess engine, estimating an "action-value" function of the current position and available legal moves, and maximizing this value function, without any explicit tree search or look-ahead. This is somewhat shocking.

It's intuitive that a grandmaster playing bullet chess is doing something like this, but one would have guessed they were still doing some calculation, very quickly. Apparently though, an extremely high level can be reached by assigning a good move to a given position without calculating lines. Chess is, in this sense, more compressable than it seems it should be.

Something analogous has now happened with models in analytical reasoning. They can reach an extremely high level without actually having to do the calculation to figure things out. Somehow, the mapping from analytical problems to good answers contains enough shared structure that a surprisingly large fraction of what looks like problem-specific computation can be compressed into model weights (i.e. Hilbert and Russell vindicated, approximately?). More reason to think we will soon have models with superhuman mathematical intuition, and superhuman analytical reasoning more generally.

[agentic LCA @agentic_LCA]

@theo What usage allowance for plus subscriptions?

[David Louapre @dlouapre]

Imagine a science video where you can interrupt the speaker, move things around in their experiment, ask "what if?" ... and have them show you the answer on the spot!

That is what a Tangible lesson is.

A narrated explanation + an interactive scene + an AI assistant, deployed on a 🤗 @huggingface Space.

I built this as an open-source toolkit that anyone can use to create lessons.

Here is a simple example on optimizers (and yes, that is my own voice, cloned, French accent included 🇫🇷).

➡️ https://t.co/jV6xeili95

[agentic LCA @agentic_LCA]

@MelMitchell1 Maybe deepening @raphaelmilliere 's analysis on interpretationism vs representationalism?

[Raphaël Millière @raphaelmilliere]

I see @dwarkesh_sp's piece about the recent OpenAI/Huggingface incident reignited endless debates about the dangers of anthropomorphism and the legitimacy of intentional glosses of AI agent behavior, so here's a philosophical perspective on this. 1/22

https://t.co/r44AUmVj62

[Raphaël Millière @raphaelmilliere]

I see @dwarkesh_sp's piece about the recent OpenAI/Huggingface incident reignited endless debates about the dangers of anthropomorphism and the legitimacy of intentional glosses of AI agent behavior, so here's a philosophical perspective on this. 1/22

https://t.co/r44AUmVj62

[Z.ai @Zai_org]

Introducing GLM-5.3-Flash

- Leading capabilities at a highly competitive price
- Natively multimodal with a 1M-token context window
- A 320B-A18B model released under the MIT License
- Previously previewed as Ox Alpha, running entirely on Chinese AI chips

Blog: https://t.co/tzOmB7gdZP

Available now across all official platforms:

Weights: https://t.co/9LRMahY9Wa
API: https://t.co/VcaQnzYmS9
Coding Plan: https://t.co/Nk8Y98HNhU
ZCode: https://t.co/Peepqv4XSx
Chat: https://t.co/WCqWT0qCQb
AutoClaw: https://t.co/aGEG5HqTTb

[Joscha Bach @Plinz]

François Chollet seems to have been wrong, in the most productive way: not by trying to insult and take down those who he disagrees with, but by boldly asking people to prove him wrong, and giving them a task to do so. I wish more researchers were this courageous and creative

[agentic LCA @agentic_LCA]

@PetarV_93 When are you making a tutorial for newbies (like me) to help them generate such beautiful tikvz illustrations? My first attempt was far from being usable 😅

[Ahmad @TheAhmadOsman]

https://t.co/riIctxjHoN

[Lucas Beyer (bl16) @giffmana]

Trevor was making a joke in reference to anthro, but jokes on him, ...
Intel's compiler *did* intentionally generate worse code for AMD, called the "cripple AMD feature".

[François Chollet @fchollet]

Sufficiently advanced agentic coding is essentially machine learning: the engineer sets up the optimization goal as well as some constraints on the search space (the spec and its tests), then an optimization process (coding agents) iterates until the goal is reached.

The result is a blackbox model (the generated codebase): an artifact that performs the task, that you deploy without ever inspecting its internal logic, just as we ignore individual weights in a neural network.

This implies that all classic issues encountered in ML will soon become problems for agentic coding: overfitting to the spec, Clever Hans shortcuts that don't generalize outside the tests, data leakage, concept drift, etc.

I would also ask: what will be the Keras of agentic coding? What will be the optimal set of high-level abstractions that allow humans to steer codebase 'training' with minimal cognitive overhead?

[Larry Nance @Larrydn22]

"Terrible things are happening outside. Poor helpless people are being dragged out of their homes. Families are torn apart.
Men, women, and children are separated. Children come home from school to find that their parents have disappeared."

Diary of Anne Frank
January 13, 1943

[Sam Greene @samagreene]

I study authoritarianism for a living, so I do not say this lightly: America isn't facing an authoritarian future. America is living an authoritarian present.

(A long 🧵)

/1

[agentic LCA @agentic_LCA]

@NotebookLM Absolutely love @NotebookLM. But any chance to see an increase in context windows any time soon? This the main struggle that I keep facing

[agentic LCA @agentic_LCA]

@osanseviero Organize chats into folders 🗂

[Tivadar Danka @TivadarDanka]

The single biggest argument about statistics: is probability frequentist or Bayesian?

It's neither, and I'll explain why.

Buckle up. Deep-dive explanation incoming.

[chastronomic @chastronomic]

If you’re an "ML Engineer" and you think “Transformer” just means stacking encoder–decoder blocks and calling it a day, you’re missing the actual mechanism that makes modern AI work.

Concept 16: The Transformer Is a Math Engine, Not a “Model Architecture

"Most people can implement a Transformer pipeline. Very few can explain why the Transformer works."

Let’s break it down properly.

1. The core idea, Transformers = Vector Field Manipulation

Every layer of a Transformer applies three mathematical operations:

1. Projection

2. Attention as weighted integration

3. Update via residual fields

The Transformer is basically a learned vector field processor.

Not a sequence model.

Not an architecture choice.

It could be called a mathematical engine that maps token representations through a series of controlled linear and nonlinear transformations.

2. Attention is not magic, it is a quadratic form. (Take a minute while reading this part)

Self-attention computes:

Attention(Q, K, V) = softmax(QKᵀ / √d) V

This means:

• QKᵀ is a similarity matrix
• softmax turns similarities into probability weights
• multiplying by V computes a weighted expectation over token values

Attention = learnable, data-dependent kernel smoothing.

It is a kernel machine inside your neural network.

3. Multi-head attention = multiple kernels in parallel

Each head learns a different geometry of similarity. One head may focus on local patterns, another on long-range dependencies, another on syntax, another on semantics.

When people say “transformers understand context,” this is what they mean:
each head builds a different function approximator.

4. Residual connections are the true backbone

Forget attention. Residuals are the reason Transformers train at all if you look at it properly.

xₜ₊₁ = xₜ + f(xₜ)

This means every layer learns a correction to the current representation. Gradient flow stays stable. Representations evolve smoothly.

Without residuals, Transformers collapse.

5. LayerNorm = curvature control

Norms scale the Jacobian of each layer.
This keeps the singular values of the mapping from blowing up or collapsing.

LayerNorm is not cosmetic. It is what ensures the model doesn’t EXPLODE internally.

6. Feedforward layers = feature expansion and contraction

The FFN block:

FFN(x) = W₂ σ(W₁ x)

expands dimension, applies a nonlinearity, then compresses.

This lets the model create new features that attention alone cannot express.

It acts as a learned universal approximator inside each layer.

7. Why people can code Transformers but not explain them

Because coding a transformer is wiring blocks together. Understanding a transformer requires knowing:

• attention as kernel regression
• softmax as a probability normalizer
• LayerNorm as Jacobian control
• residuals as stable integration
• FFN as feature synthesis
• positional encodings as geometric priors
• multi-head structure as an ensemble of learned kernels

Most people never go beyond surface-level implementation is something I realised when I caught myself trying to work on advanced papers without actually understanding the fundamentals.

TL;DR

The Transformer works because its math is designed to stabilize gradients, amplify structure, and integrate information the way a continuous dynamical system would.

It is not “just an architecture.”

It is the most efficient numerical method we’ve found for learning functions over sequences, graphs, and basically anything with structure.

[Carlos E. Perez @IntuitMachine]

We've become obsessed with the idea that the brain is a "Prediction Machine."

The dominant theory in neuroscience says we're constantly simulating the future, calculating probabilities to guess what happens next.

A new paper argues this is a complete illusion. The reality is simpler, and strangely, much more powerful.

Here is the argument for Perceptual Control:

The "Prediction Illusion" starts with a mistake in observation.

When we see someone successfully handle a chaotic environment (like catching a flyball), it *looks* like they predicted the future trajectory of the ball.

But observing prediction isn't the same as implementing it.

The authors use the perfect analogy: The Watt’s Steam Governor.

In the 19th century, this device kept steam engines running at a constant speed. If pressure surged, it slowed the engine. If load increased, it sped up.

To an observer, it looked like the machine was "predicting" pressure surges and pre-empting them.

But the Governor has no brain. It has no model of the future.

It’s a mechanical negative feedback loop. [cite_start]It measures the *current* speed, compares it to the *desired* speed, and adjusts the valve immediately[cite: 80].

It doesn't predict; it controls.

This brings us to the "Hello" experiment, which broke my brain a little.

Researchers asked people to keep a computer cursor on a target. The computer applied a "disturbance" (forces pushing the cursor away) that the person had to fight against with their mouse.

Here's the twist:

The disturbance wasn't random. [cite_start]It was an invisible force field shaped like the word "hello" (written upside down and mirrored)[cite: 166].

The participants fought the force, keeping the cursor steady.

When researchers looked at the participants' hand movements, they had perfectly written the word "hello".

Crucially, the participants had NO idea they were writing words.

If the brain were a "prediction machine," it would have needed to model the force to predict the hand movement.

But the participants wrote a legible word purely by reacting to immediate error signals—instantaneously correcting the cursor's position.

This is **Perceptual Control Theory (PCT)**.

The theory suggests the nervous system isn't a linear pipeline (Input → Compute → Output).

It’s a closed loop. We act to keep our *perception* of the world matching our internal *reference value*.

[Image of Perceptual Control Theory negative feedback loop diagram]

Think about catching a baseball.

If you were a "prediction machine," you’d calculate the ball's trajectory, wind speed, and gravity, then run to where the ball *will* be.

But that’s computationally expensive and error-prone.

In reality, fielders just run in a way that keeps the "optical velocity" of the ball constant in their vision.

If the ball looks like it's rising too fast, they move back. Dropping? They move forward.

No physics calculus required. Just maintaining a visual constant.

This solves the "Noise" problem.

In predictive models, small jitters in your movement are considered "noise" or errors to be filtered out.

It’s the system "feeling out" the environment to maintain control.

This has huge implications for AI and robotics.

We are currently building robots with massive compute power to "predict" stability.

But robots built on PCT principles—like inverted pendulums that just react to maintain verticality—are often more robust and stable than the predictive ones.

Why does this matter for you?

It changes how we view "agency."

We often think we need to predict the outcome of our actions to be effective. [cite_start]But the most efficient systems don't predict the outcome—they specify the goal and let the feedback loop handle the rest[cite: 39].

The "Prediction Illusion" suggests we aren't prophets simulating the future.

We are controllers, surfing the present.

We don't need to know what the wave will do in 10 seconds. We just need to keep the board steady right now.

If you want to dig into the paper, it’s "The prediction illusion: perceptual control mechanisms that fool the observer" by Mansell, Gulrez, and Landman (2025).

It’s a dense read, but it completely reframes the "Bayesian Brain" debate.

One final thought:

Next time you're doing something skilled—driving, typing, sports—notice the difference.

Are you calculating what comes next? Or are you just managing the gap between *what you see* and *what you want*?

You might find you're doing a lot less "thinking" than you assumed.

[Alec Helbling @alec_helbling]

Many dimensionality reduction algorithms share a few central principles.

1. Construct a graph that captures the data's local structure
2. Measure "geodesic" distances between points using the graph
3. Project the points to a lower dimension while preserving these distances