evnsnclr

AI Research @ Georgia Institute of Technology
ds@gt arc:

[evnsnclr @evnsnclr]

@iansilber What we’ve all been waiting for 🙏

[Ian Silber @iansilber]

new codex pet

[evnsnclr @evnsnclr]

@phillipyan Congrats! @phillipyan

[evnsnclr @evnsnclr]

Holt shit this blew up

For clarification, I am not simulating a fly’s consciousness or uploading a living brain into the game.

The demo uses a reconstructed map of fruit fly neural connections, with simplified rules for how activity moves through that network. Minecraft events feed into the model, and activity in selected neuron groups helps choose and adjust movements I programmed, like flying, grooming, feeding, or escaping.

The wiring comes from biological data, but the activity model, game inputs, and movement mappings involve engineering choices. It’s an interactive way to explore a connectome, not evidence of consciousness or a complete recreation of a living fly.

[evnsnclr @evnsnclr]

I’ve successfully run the full retained MaleCNS v1.0 fruit fly connectome, all 166,700 neurons, inside Minecraft, with its simulated neural activity driving a fly’s movement.

V1 Currently in development. Built with the help of GPT-6 Astra.

Props to the @OpenAI team and @thsottiaux for this release. Code and mod coming soon!

[News from Google @NewsFromGoogle]

For the first time, scientists have mapped the complete brain and central nervous system of an adult male fruit fly — a key model organism in science. 🪰

Working alongside HHMI Janelia Research Campus and the scientific community, @GoogleResearch scientists and researchers used AI to combine millions of 2D images into 3D neural shapes, reconstructing a record-breaking 166,000+ neurons. This foundational map of the adult male fruit fly brain can help accelerate our understanding of the brain, and is a major milestone in neuroscience.

[evnsnclr @evnsnclr]

Thanks for the shoutout @polymarket

[Polymarket @Polymarket]

JUST IN: Developer uses GPT-6 Astra to run a 166,700-neuron fruit fly brain simulation inside Minecraft.

[Declan Kutscher @kutsch_d]

@evnsnclr @OpenAI Cool demo, but people are overinterpreting it.

Running the connectome does not mean it is generating fly-like behavior. Eon’s demo had the same issue. The behavior largely came from NeuroMechFly’s locomotion controllers. There’s no evidence the connectome itself was necessary.

[evnsnclr @evnsnclr]

@Polymarket thanks for the shoutout @Polymarket

[evnsnclr @evnsnclr]

@Dan_Jeffries1 @OpenAI done

[evnsnclr @evnsnclr]

@reddit_lies I did. He has sugar, too. He's vibing

[evnsnclr @evnsnclr]

@Dan_Jeffries1 @OpenAI Demo coming soon

[evnsnclr @evnsnclr]

@ashebytes This is fantastic! @ashebytes checking it out now

[evnsnclr @evnsnclr]

@fofrAI This is amazing!!

[ueaj @_ueaj]

I don't think OpenAI is doing looped transformers, though it is possible they're doing something like MoEUT. However, that doesn't really explain how they are actually eliciting significantly denser reasoning. I don't think the RL signal is dense enough to saturate frontier math with minimal reasoning or perform complex actions without reasoning at all.

Instead, it's far more likely they're doing synthetic rewriting of CoTs. Rewriting them to be terser, or outright dropping parts of the CoT and asking the next generation pretrain to fill in the middle, essentially internalizing the reasoning patterns deep in the weights.

This is likely to me for many reasons, the first is that it gets around the RL signal problem. You turn a RL task into a dense SFT/pretraining task, so the signal is far denser and you get more bits per episode. The second is that it's simple and true breakthroughs are rare, and it's something that needs to happen at scale (you need pretraining scale data for this to work).

If you're markov brained, the original CoT is our data generating process, and by dropping parts of it, we force the model to reconstruct the hidden variables (the hidden parts of the CoT) but in the model weights instead.

(blog below)

[evnsnclr @evnsnclr]

@BrianDShields @OpenAI These guys did something similar: https://t.co/3vh24Vzwze

[Sebastian Raschka @rasbt]

A lot of hype around OpenAI's Astra model here on my timeline today. Apparently, this goes back to a new article from The Information, which said Astra is a "recurrent depth or looped transformer".

It's always interesting to read about new or different approaches (including rumors about what the closed labs may be up to), but let's debunk this a bit.

About 2 months ago, I shared the architecture details of Nanbeige, for example, where "Nanbeige4.2-3B is pretrained from scratch on 28T tokens with a Looped Transformer that reuses the layer stack to increase capacity without adding parameters."

Yes, that's it. The looped transformer idea is just reusing layers in the transformer block.

In the case of Nanbeige, the main idea is to reuse the same 22-layer stack (=transformer block) twice instead of once. So, effectively it extends the 22-layer architecture to 44 layers, but without duplicating the weights.

In simple terms, this roughly doubles the size of the model (if we ignore the embedding and output layers for a second). But instead of requiring 2x the storage and RAM to host this model, it stays at the same size since we reuse the components. However, it's almost 2x as expensive in terms of compute, because we run the embedded text through almost 2x as many layers.

Why? In the Nanbeige 4.2 technical report, the researchers found that two passes gave the best trade-off and retained about 75% of the token efficiency of a standard architecture. (More passes gave barely any gains but made the training much slower and much more expensive.)

While, as far as I know, Nanbeige 4.2 is the first notable open-weight model that adopted this approach, the idea goes back to the NeurIPS paper "Mixture-of-recursions: Learning dynamic recursive depths for adaptive token-level computation". Actually, this paper proposes a mechanism that is a bit more sophisticated by adding a learned router that determines whether each token receives one, two, or more passes. So, easy tokens can exit early while harder tokens receive additional computation.

In sum, Astra may be a really good model, but this shouldn't be about this "looped transformer aspect," which is just a tiny architectural tweak.

Also, the statement "the new technique works in a way that obscures some or all of the AI's reasoning, otherwise known as 'chain-of-thought'" is not necessarily true with respect to the looped transformer method. It's possible that The Information journalist refers to some other technique or misunderstood the looped transformer method.

Reusing layers does not by itself suppress visible chain of thought. It adds computation in hidden states before the next token is emitted, just as ordinary transformer layers do.

But based on the information we have, the only plausible interpretation here is that if a model uses more of these recurrent passes, it may need to generate fewer intermediate reasoning tokens. So then more of its computation happens in latent activations that cannot be read as text. But we would get the same effect if we were scaling up the model size, like GPT 5.6 Luna -> GPT 5.6 Sol.

[News from Google @NewsFromGoogle]

Introducing WeatherNext 3, our most advanced and accurate global weather AI model to date, from @GoogleDeepMind and @GoogleResearch.

This new forecasting model learns directly from real-time observations, and uses raw satellite data to produce a forecast every hour in high resolution. These breakthroughs mean it can provide timely and more localized predictions, bringing even more reliable forecasts across Google products worldwide, including Search, Gemini and Maps.

[Alec Helbling @alec_helbling]

Introducing Flow Reasoning Models.

We developed a recurrent flow-based architecture to efficiently solve structured reasoning problems (e.g., Sudoku).

FRMs apply continuous flows to discrete data and recurrently refine their past mistakes through self-conditioning.