pow

#bitcoin

[Massimo @Rainmaker1973]

The reason why you can't see the curvature of the Earth.

[codila @0xCodila]

Anthropic Engineer Andrej Karpathy:

"The biggest mistake in AI right now - people are forcing agents to work instead of mastering the model first

We made that mistake in 2016 at OpenAI - It cost us 5 years "

what Karpathy actually means:

step 1 → stop forcing your agent to do everything, understand the model underneath first

step 2 → demos are easy - products take a decade. self-driving proved it - if you skip the foundation, everything breaks

step 3 → the agent is not the product. the foundation is. build that - and agents emerge on their own

"you building agents right now - you're at the forefront. not OpenAI. not DeepMind. you "

watch - bookmark, then read article below ↓

[Iris Hayes @irisneural]

🚨 BREAKING NEWS: Claude has launched a new feature called Council!
Instead of Claude responding with "one head," you can now have 5 heads discuss and debate with each other, then give you the final answer.
Here's how to use it + 5 powerful prompts:
(Save this thread)

[NO1ennn @N01ennn]

A 21-YEAR-OLD FROM CHINA RUNS 300 AI AGENTS AT ONCE. THE PART THAT MATTERS ISN'T THE SPEED, IT'S THAT NONE OF THEM CAN LIE TO HIM

he opens the dashboard and shows the swarm live, 300 Kimi K2.6 agents firing in parallel, then Opus 4.8 checking every single output against its source. this is not just a faster swarm. it is a loop that refuses to stop while anything is still wrong

he pointed it at 100 EV-market companies. first pass: 12 failed. wrong revenue, dead citations, empty fields. second pass: 3 failed. third pass: zero

this is not another agent demo. it is a system that catches its own mistakes before he reads a single row

[Fabio Guzman @FGuzmanAI]

56,000+ tokens/sec at just 80 MHz. 🤯

I burned a full Transformer with KV cache into a custom chip. Designed gate by gate as a 100% digital integrated circuit. Prototyped on a FPGA. (No GPU. No CPU)
Just pure digital silicon running @karpathy microGPT, spelling out names on a tiny LCD.

This is GateGPT 👇

[Avi Chawla @_avichawla]

Karpathy said something you'll regret ignoring:

"Remove yourself as the bottleneck. Maximize your leverage. Put in very few tokens, and a huge amount of stuff happens on your behalf."

The reason most people can't do this today is because their AI has little to no memory of their work.

You sit in meetings, read threads, make decisions, and your brain quietly drops half of it by next week. Then you spend time re-reading, re-asking, re-explaining context to your own AI.

You can't remove yourself from the loop when YOU are the only one who remembers what happened.

That's why the smartest builders are setting up AI second brains that compound everything automatically.

Rowboat is an open-source implementation of exactly this, built on top of the same Markdown-and-Obsidian foundation that Karpathy uses, but extended into a work context.

Emails, meetings, decisions, commitments, and deadlines, everything is linked in a knowledge graph that gets denser every day without you touching it.

And the whole setup runs 100% locally.

6 months from now, you'll either have an AI second brain or wish you did.

Find my full 100% local setup guide in the article quoted below to start today.

Here's the Rowboat Repo: https://t.co/tiNTv2NhUF

(don't forget to star it 🌟)

[Akshay 🚀 @akshay_pachaar]

Prefill vs decode in LLM inference.

Ever wondered why the first token always takes a moment to appear, but the rest stream out almost instantly? That gap isn't network lag or model warmup, it's a structural property of how LLMs actually run.

Inference happens in two phases that share the same model and the same code path, but the workload looks completely different in each, and the bottlenecks are opposite.

𝗣𝗿𝗲𝗳𝗶𝗹𝗹 is what happens when you submit a prompt. The model processes every input token in one parallel pass, computing Q, K, and V for all of them at once.

Attention runs as a giant matrix multiplication, which is exactly what GPUs were built for, so the chip pegs at high utilization doing math as fast as the silicon allows.

Prefill is compute-bound, and the metric that captures it is Time to First Token.

𝗗𝗲𝗰𝗼𝗱𝗲 is what happens once the first token is out. To generate the next one, the model only computes Q, K, and V for that single new token, because everything before it is already cached.

So the model loops one token per forward pass, multiplying a single query against the cached keys instead of a full matrix, and the arithmetic becomes tiny.

But the GPU still has to load every weight and every cached entry from memory to do that tiny computation, so the bottleneck flips and compute sits idle while memory bandwidth becomes the limit.

Decode is memory-bound, and the metric that captures it is Inter-Token Latency.

This one split explains a lot of things that look mysterious from the outside.

GPU utilization looks great during prefill and drops sharply during decode because memory, not compute, is the bottleneck in the second phase.

Throwing more compute at a slow-streaming model often does nothing because the fix for memory-bound workloads is faster memory or a smaller cache, not more FLOPs.

Long contexts feel disproportionately slow because the KV cache grows with every token, and every decode step has to read all of it.

That cache is the optimization that makes decode viable in the first place, since without it, every new token would force a recomputation of attention over the entire growing sequence.

With it, the cache is built once during prefill, then grows by exactly one entry per decode step, with existing entries reused rather than recomputed.

But the cache lives in GPU memory and grows linearly with sequence length, so for a 13B model that's roughly 1 MB per token, which means a 4K context burns 4 GB of VRAM on the cache alone.

This is why long contexts feel slow, not because the model runs out of brainpower, but because the cache runs out of room.

The entire field is now optimizing around this constraint with quantized caches, sliding windows, grouped-query attention, and PagedAttention, while DeepSeek's V4 series goes further and redesigns attention itself so the cache stays small from the start.

When attention is being redesigned to fit the cache, you know the constraint has shifted.

The practical takeaway is that when someone says their model feels slow, the first question is whether it's slow to start or slow to stream. Slow to start means prefill and a compute bottleneck, while slow to stream means decode and a memory bottleneck.

The article below is a first-principles guide to LLM inference that walks through everything between your prompt and the streamed response, covering tokenization, embeddings, attention, the prefill and decode split, KV caching, and quantization. If you want a complete mental model of how inference actually works under the hood, give it a read.

Cheers!

[Sigrid Jin 🌈🙏 @realsigridjin]

this paper drops a big hint about why claude mythos so good

> theory: it's a looped transformer (lt). instead of stacking more layers, you loop the same layers multiple times

> the authors tested two hard problems that break normal transformers.
> systematic generalization → can the model combine facts it never saw combined during training?
> depth extrapolation → can it reason deeper than anything in training data?
> vanilla transformers fail both but looped transformers pass both

> the systematic generalization result is wild, training goes through 3 distinct phases, then suddenly groks it, ood performance jumps off a cliff upward
> depth extrapolation is even wilder, train on 20-hop reasoning, test on 30-hop, it just works. the trick is adding more loop iterations at inference

> so more loops = deeper reasoning chains
> no chain of thought needed. this is all happening inside one forward pass

> current llms already memorize tons of facts during pretraining
> the bottleneck is composition, they can't chain what they know to answer novel questions
> loops seem to unlock that composition for free

> if mythos is actually running this architecture, it explains the vibes, same weights, more thinking, better answers on hard stuff
> expect everyone to start pretraining looped models next

[Kye Gomez (swarms) @KyeGomezB]

Introducing OpenMythos

An open-source, first-principles theoretical reconstruction of Claude Mythos, implemented in PyTorch.

The architecture instantiates a looped transformer with a Mixture-of-Experts (MoE) routing mechanism, enabling iterative depth via weight sharing and conditional computation across experts.

My implementation explores the hypothesis that recursive application of a fixed parameterized block, coupled with sparse expert activation, can yield improved efficiency–performance tradeoffs and emergent multi-step reasoning.

Learn more ⬇️🧵

[Hayden Prairie @hayden_prairie]

We’ve been thinking a lot about scaling laws, wondering if there is a more effective way to scale FLOPs without increasing parameters.

Turns out the answer is YES – by looping blocks of layers during training. We find that predictable scaling laws exist for layer looping, allowing us to use looping to achieve the quality of a Transformer twice the size.

Our scaling laws suggest that for a fixed parameter budget, data and looping should be increased in tandem!

🧵👇

[Yuekun Yao @yuekun_yao]

Claude Mythos is suspected of being a Looped transformer (LT), but why are LT-based LLMs so powerful?

Our new finding: LT can perform implicit reasoning over their parametric knowledge, unlocking generalization to complex and unfamiliar questions compared to transformers ⤵️

[Khairallah AL-Awady @eng_khairallah1]

> "i don't have time to automate"
> spend 3 hours on repetitive tasks daily
> "i really don't have time"
> spend 3 more hours tomorrow
> and the next day
> find 40 Claude automations you can build
> build one in 45 minutes
> 3 hours daily gone forever
> had time the whole time

[Ben Sigman @bensig]

Which AI memory system is best for you?

I compared 4 open-source memory systems for AI agents:

mempalace - verbatim storage, fully offline, MIT
claude-mem - silent capture for Claude Code, AGPL
mem0 - pluggable SDK with 30+ vector stores, Apache-2.0
supermemory - managed engine with user profiles, ~50ms

Key findings:

- mempalace scored highest overall (8.25/10) with perfect data integrity - nothing is lost or summarized

- mem0 has the most mature architecture but highest operational complexity

- claude-mem is unbeatable if you live in Claude Code, but locked to that ecosystem

- supermemory scores high benchmars, but requires cloud + proprietary license ($)

No single system wins everywhere.

The right choice depends on your constraints: privacy, simplicity, flexibility, or managed infra.

Full comparison in the images below.

Disclosure: I built mempalace. Eval was run by a separate LLM I don't use, fed all 4 codebases blind.

[Carlos E. Perez @IntuitMachine]

https://t.co/lMDyeqNavg

[Garry Tan @garrytan]

https://t.co/EVPCod6rxu

[Rohit @rohit4verse]

Anthropic's CEO: "coding is going away first. then all of software engineering."

the 5% that survives? systems thinking.

3 months ago I published 5 projects for this exact moment. 21K bookmarked it.

not syntax. orchestration. harness. memory. edge inference.

[Defileo🔮 @defileo]

https://t.co/XknL2qFBAP

[pdawg @prathamgrv]

I made a Claude Code skill that turns any arxiv paper into working code.

Every line traces back to the paper section it came from & any implementation detail the paper skips will be flagged, and not assumed.

open sourcing it -
https://t.co/sSio4JfpIo

[Aakash Gupta @aakashgupta]

Point your agent to this and thank me later.

[Katyayani Shukla @aibytekat]

🚨 BREAKING: Claude can now prep you for FAANG interviews like a $1,000/hour executive career coach. For free.

Here are 18 prompts that get you past the final round within 14 days: