escape_montage

[Polonus🧯 @Polonus17]

Prawie wszyscy mają roztrzaskane głowy…
Bestialstwo Ukraińców przeraża cały cywilizowany świat!

[jacky @jjacky]

whoever shared the "i have adhd" skill with me

thank you

it's made my claude replies so good

[Ray🫧 @ravikiran_dev7]

Claude: “this project will probably take 3 months to complete”

Me:

[W! @w1fi0]

He woke the beast
Big mistake 💀

[Google Gemma @googlegemma]

Just dropped: The Gemma 4 Technical Report!

Dive into the decisions behind our latest open-weight multimodal models, Gemma 4 (E2B–31B). Discover details on how the Gemma team approaches architecture, efficiency and responsibility. The report also covers the recent encoder-free 12B variant, quantization-aware training and multi-token prediction (MTP) drafters.

[Zhengyao Jiang @zhengyaojiang]

The first experimental evidence of recursive self-improvement (RSI).

Autoresearching the autoresearch agent for eight days.

The result beats the harness we hand-tuned for two years, on held-out benchmarks: 🧵(1/7)

[Alex Toussaint @alextoussss]

Extremely excited to announce our first air-to-air kill of a flying moth by an autonomous micro-drone. This is a big step towards completely eradicating mosquitoes.

[Troll Football @TrollFootball]

What Dembélé will see every time he turns around today

[escape_montage @escape_montage]

@sama @TheAhmadOsman fable is so slow, it's unusable honestly

[Li Zexin 李泽欣 @XH_Lee23]

A historic day in China's space history. China’s first successful rocket recovery!

[1X @1x_tech]

NEO’s Hands
An API to the Physical World

[escape_montage @escape_montage]

@RozekTom To rzadkość że się mogę zgodzić z czymś co pisze rożek

[koza. @kzvsky]

Messi wysyłany na emeryturę przy 0:2

[willo2 @willo2_Poly]

1 month ago, Polymarket scammed me for $500K, with 1,868 traders losing a total of $6.5M.

Now we're taking Polymarket to court.

[Psyho @FakePsyho]

My nuanced predictions for the AWTF heuristic human vs AI:

You may think that since OpenAI took 2nd place in 2025 and the progress over the last year has been insane this should be an easy win for the AI. It's not. At least not an easy one.

There are a lot of things that I need to cover so let me briefly go over everything that's important.

Where AI agents are today:
- Produce code at insane speeds; a single agent is probably one-two orders of magnitude faster than the fastest humans
- Excellent at finding relevant and applicable knowledge
- Good at reasoning about problems that are easily explainable via text
- Code quality and expressiveness is much better but still behind very good coders, this mostly matters in larger projects so it's unclear if this will have any impact here
- Standard autoresearch tends to easily get stuck in local minima
- Surprisingly bad at code optimization. If you believe otherwise... I'm sorry.

Performing well in complex optimization problems requires the following:
- Very good and thorough problem understanding. For common problems it's enough to apply and tweak existing knowledge, but with truly unique problems you really need some form of continual learning.
- Being able to quickly implement all ideas. Solving those complex problems is an iterative process: each time you test a new idea, you gain new knowledge that improves your understanding of the problem. The quicker you go, the more information you'll be able to extract.
- Squeezing the maximum performance out of your idea. This often requires performing many tests with minor tweaks.

It's also worth noting that IMHO humans heavily underperformed (including me, due to lack of sleep) in 2025. If I competed in isolation (without a leaderboard), my guess would be that I'd probably finish around 4-6th place.

Based on everything above we can say that the main advantage of AI is insane speed and the ability to parallelize work, but its main weakness is that as time goes on it won't be much smarter about the problem it's trying to solve. If you need a simple analogy: AI here is like 100 okay-ish programmers heavily cooperating with each other.

The longer the contest goes and the more unique the problem is, the higher the chances for humans are. On the other hand, if the problem is very heavy on the implementation side and/or we can arrive at great solution by performing small tweaks (i.e. the gradient from "random solution" to a very good one is smooth), humans won't have much of a chance.

In 2025, problem setters assumed that AI is not that good yet and the problem wasn't "AI-proofed". I'm pretty sure that this year there was a lot of thought put into problem design and we can expect something truly unique. I'm sure that there exists many different problems where humans have a good chance of winning vs AI, but finding them might be very tricky and obviously AtCoder cannot test against the best in-house model that OpenAI currently has.

On the other hand, one might ask yourself why in 2026 OpenAI decided to compete again vs humans. In 2025 they had a very strong result in IMO, got the 2nd place at AWTF heuristic and solved all of the problems at the ICPC. That would be a huge narrative violation if in 2026 they didn't easily win, right? Considering this, I expect that OpenAI put some actual effort into it and this is not just the same thing they did in 2025 with a stronger underlying model. A lot of current AI downsides can be alleviated by better harness (in order to improve exploration of different ideas) and massive parallelization. Since it's OpenAI official participation, we can safely assume that OpenAI has infinite inference at its disposal here. With massive inference issues like "bad at code optimization" should mostly disappear.

Ok, that's a lot of text, so what's my actual prediction?

I do believe that OpenAI put significant effort and expects to win. If they were consistently winning online 10-day contests then winning 2-day finals should be easy. I'm also sure that AtCoder's final problem is going to be very unique and completely unrelated to any of the past problems.

Unless OpenAI slowplays their advantage, we should expect that once again they will have a crushing lead right from the start. Once again humans will be playing a catch-up game. We might expect some tweets from OpenAI if their advantage is huge near the end of the competition, but I wouldn't be surprised if they wait till they get their full sweep with both heuristic & algo.

In the end, I think I give humans around 20-25% chance of winning. Either way, this should be both entertaining and educational since we rarely get a chance to see any of the frontier AI labs trying to put their best in-house models to the test.

[Big Boss @0xBADB01E]

So following these principles here is the architecture that falls out and it’s quite different than what is thought to be optimal today.

Starting with the memory: LPDDR6 tops out around 14.4 Gb/s per pin. We would want to as many channels as the die’s edge can carry. If we can fit 24 channels, that’s 576 data pins, and you get ~1 TB/s per chip with 192 GB of storage. Same as the b200 in size but about an a100 in bandwidth.

But remember that LPDDR access latency is ~100 ns which is about the same as HBM. So streaming weights from LPDDR costs you nothing on latency and we just give up per package bandwidth, and remember our pipelining already collapsed that requirement.

Now work backwards to compute. Tokens/sec = ~aggregate BW / bytes touched per token, and at batch 64 in FP4 every delivered byte wants ~256 FLOPs. 1 TB/s × 256 = ~260 TF of FP4. Size ~280 TF for some headroom and stop! That’s all we need, the rest of the alpha is in latency tuning not flops.

Now process node, again using first principles thinking. On TSMC N6 that MAC array would be about 30 mm^2. The rest of the die goes to SRAM buffers, 24 LPDDR PHYs, and 56 lanes of plain 32 GT/s NRZ SerDes PCIe 5.0 transceivers, nothing exotic. Because we didn’t provision more flops we can provision what we really need which is ports. If we do 7 ports × x8 we can get a full mesh across 8 chips with ~224 GB/s any to any ops, sized for 8 KB activations instead of 100 MB gradients. Approximate Total Area: ~144 mm^2, ~180W with the DRAM. Fucking Mobile SoC level economics.

And we get away without a crazy process node. N3 shrinks your logic, but that’s actually the one thing this die barely has. SRAM stopped scaling and the PHYs and SerDes are analog so they don’t shrink at all. An N3 port shrinks ~20% of the floorplan, and saves maybe 10-15W, but doubles the cost on a small die that already has beautiful *chefs kiss* 👨‍🍳💋 yield.

Now do the node math:

8 chips (b/c full mesh w/ 7 ports) = 8 TB/s aggregate BW, 1.5 TB total of memory, and ~1.44 kW. A B200 inside an NVL72 is 8 TB/s, 192 GB, ~1.67 kW all in. So we are basically neck and neck on BW with a b200 with slightly lower power because we have more chips connected with quicker interconnects allowing them to act as a single unit.

If we scale to the rack level at 72 nodes, that 576 chips, 576 TB/s which is again the same aggregate bandwidth as a GB200 NVL72, so approximately the same tokens/sec by construction but with ~104 kW of power against ~120-130 and 110 TB of memory against 13.8 TB of the NVL72. So in summary 4.5x less compute silicon, zero HBM, zero CoWoS, zero leading-edge nodes and still token/watt ~20% better.

So what’s stopping everyone from doing this? The number I told you hold whether you want to believe it or not and get even more competitive with longer reasoning chains or agentic workloads because as you scale those the all reduces now sits on the critical path of every token and on a 30 ns link with a full mesh that’s orders of magnitudes of token throughput improvements over Nvidia’s stack. Counterintuitively the link latency, not the chip architecture, decides your memory, logic, and everything else!

Thanks for reading if you made it this far.

[Big Boss @0xBADB01E]

First you have to understand that modern LLM inference already disaggregates weights as models outgrew single chips years ago. You shard either by layer (pipeline parallelism) or by slicing every layer (tensor parallelism), and the two do very different things.

As an example, let’s look at Llama 3.3. It has 70B of weights and at FP8 that’s 70 GB of memory which is enough to fit on a single H100. Now that H100 has 3.35 TB/s of HBM, so the fastest it can ever decode for one user is 70/3.35 ≈ 21 ms/token or ~48 tok/s while using under 1% of its FLOPs. Now if we pipeline it across 8 chips: each chip holds ~8.75 GB, which means it only needs 1/8th the bandwidth and 1/8th the FLOPs to sustain the same aggregate throughput. Now crucially the token/sec a user gets is limited by the amount of data that crosses the link. In current LLMs all that is a small amount of activations for LLama 3.3 it’s ~8 KB per token….

Yes, you read that right it’s 8 KILOBYTES we are sending over a <900 GB/s link. That’s only 9 ns of serialization time but the overhead of 224G PAM4 SerDes adds ~100 ns per link traversal with RS-FEC which is 11x longer than the payload itself. And then you have the NVSwitch adding ~300 ns per hop and you need to pay twice. That’s ~600 ns of just hardware latency wrapped around 9 ns of data making a 98% tax before software even shows up. Then NCCL’s collective stack turns 600 ns into 10-20+ us… all to move 8 kilobytes lol. For comparison 8 KB serializes over 10 Gigabit Ethernet NRZ, in just 6.6 us. Pipeline parallelism however doesn’t make a single user faster as the token still needs to visit every layer in the sequence, so per-user speed is still weights / per-chip bandwidth.

To get more speed per user token you need to use tensor parallelism and have all the chips work on the same layer simultaneously. TP costs you 2 all reduce OPs per layer, 160 per token on llama 3, that’s still kilobytes of traffic but with NVLink overhead it’s a massive tax and why pipeline parallelism on most models still gives more interactivity per user. However, this gives you a huge latency lever to pull that scales tokens per second with interconnect speed instead of memory BW.

The clever amongst you might have also realized that sharding doesn’t just cut memory bandwidth per chip it also cuts FLOPs per chip and is why we have such bad MFU on decode. So once you’ve sized the link for the memory, you need to size the compute for it too. This is called “balancing the pipeline”, and currently no shipping chip does it because they were all designed as standalone monsters. Remember Tokens/sec = ~aggregate memory BW / bytes touched per token. At batch 64 in FP4 you need ~250 FLOPs per byte, and Blackwell ships 1,250. Provisioned 5x more than the narrow pipe of HBM. Nobody saturates shit cause they are all building around HBM.

So now it all comes full circle. Parallelism reduces memory bw pressure and thus FLOPs but increases interconnect latency pressure. Despite having HBM and GigaSERDES we aren’t actually doing more work lol. But if you really wanted to balance the pipeline you need to match the memory bandwidth, the flops, and most importantly the interconnect.

So what does that look like ? Well if you build around LPDDR’s lower bandwidth, lower your interconnect latency, you actually can beat Nvidia on decode with a fraction of the silicon.

[Israel Exposed @xIsraelExposedx]

It took a little longer than expected, but we have created a website for people to view the footage collected from Gaza in one place. You no longer have to download the entire archives to see them.

It includes:

64,537 videos
17,905 photos
Ability to download individual videos
Searchable index
Exhaustive sources list (300+ journalists)
Geolocation data
Livemap with minute to minute updates
Victim list

It can be accessed here: https://t.co/s0Se94PXWF

Please share & quote tweet to help this post break out of the twitter algorithm prison.

We will keep adding the rest of the archives to the site, be patient- it is difficult work. Continue to seed the torrents provided, as that is the best way to ensure the footage remains stored in decentalized way.

God bless all those who sacrificed their lives to get this footage out, and everyone invovled in collecting/archiving it.

Join our telegram:
https://t.co/bvcis3b9GT
Follow our backup accounts:
@ZionismExposedx & @IsraelExposedAr

[Neuralink @neuralink]

The dura is the brain's armor: a membrane so tough that a surgeon normally cuts through it with a scalpel. For the first time in our clinical trials, we inserted the electrode threads of our implant straight through the dura and into the cortex, keeping the dura intact.

Here's how we did it 🧵