pur3st

Ben.

[Miles Deutscher @milesdeutscher]

This is an insane Fable 5 UI/UX hack.

This "Taste" skill completely kills generic AI-slop and gives Fable 5 the tools & instructions needed to ship beautiful design.

This might just be the best AI skill I've ever used.

https://t.co/XVQ6JpjYCy

[Avi Chawla @_avichawla]

A tricky LLM interview question:

You're serving a reasoning model on vLLM, and it keeps running out of GPU memory on long traces.

So you add KV cache compression and evict 90% of the cached tokens.

VRAM usage stays as is and GPU still runs out of memory.

Why?

(answer below)

Evicting 90% of the KV cache can free almost none of the memory it was using.

This sounds counterintuitive, but it follows directly from how production servers store the cache today.

The KV cache grows with every token a model generates. Each token appends its key and value vectors across every layer, and nothing is freed while generation continues.

This is the dominant memory cost for reasoning models.

If a 32K-token CoT caches ~32K tokens of KV vectors, a Qwen3-32B with 4-bit weights will run out-of-memory around 24K tokens on a 24GB GPU.

One obvious solution is to keep the important tokens and drop the rest, since attention is sparse enough to allow it.

But this does not solve the memory problem yet.

The reason is paged attention, which is the memory manager behind vLLM and most production servers.

Under the hood, it splits GPU memory into fixed physical blocks, each one holds the KV for about 16 tokens.

This block returns to the allocator only when every slot inside it is empty.

Since the eviction logic selects tokens by importance, and such tokens are scattered across blocks...

...so despite eviction, almost every block is left with at least some survivor tokens.

For instance, if the logic evicts 14k of 16k tokens across 1,000 blocks, most likely every block will still have a token.

This means the allocator frees almost nothing.

Placing the new tokens into those freed slots is not ideal because it breaks the cache's layout.

Say token 16,001 arrives, and it's placed in the slot the 40th token used to hold. The cache now reads position 38, then 16,001, then 41, so the cache is no longer in token order.

Attention can still compute the right answer from that, but only if every slot now carries a separate note recording which position it actually holds.

This introduces another bookkeeping cost that an in-order layout inherently avoids.

So the cache is logically 90% smaller and still physically the same size. Many compression results miss this because they measure on pre-allocated contiguous tensors rather than a paged server.

There's another problem.

Eviction methods pick which tokens to keep by looking at the attention scores themselves (as expected).

But fast attention kernels used in production, like FlashAttention, never save those scores.

They compute attention in small pieces and throw the full score grid away as they go, which is also why they're fast.

So the exact signal eviction methods need isn't available in memory. The workaround is to fall back to eager attention and build the full matrix, which gives up the speed FlashAttention was there to provide.

NVIDIA published a method called TriAttention to solve both these problems.

It never needs attention scores. Instead, it scores tokens from the geometry of the model's key and query vectors before RoPE is applied, where those vectors sit in stable clusters.

For the memory problem, it runs a compaction pass every 128 decoded tokens.

The surviving tokens slide forward to close the holes eviction creates, so whole blocks empty out and return to the allocator while the cache stays in token order.

On long reasoning traces, the approach matches full-attention accuracy while decoding 2.5x faster and using 10.7x less KV memory.

KV cache compression is a big infrastructure problem. The number that decides whether it works is the count of freed blocks, not the count of evicted tokens.

You can find the NVIDIA write-up here: https://t.co/ZwXv7VezVu

I wrote a first-principles breakdown of how the KV cache works. It walks through why the model stores keys and values at all, why the cache grows with every token, and a comparison of LLM generation speed with and without KV caching.

Read it below.

[Lilian Weng @lilianweng]

A super long overdue (3+ years?) post on scaling laws.

Compute is expensive. Scaling laws are a way to help us reason about the optimal compute allocation between data and model size before committing to a large run.

The post covers what scaling laws predict, how compute-optimal allocation works, why Kaplan et al. and Chinchilla disagree, and how data limits + fitting details make extrapolation tricky.

https://t.co/HP26eJvjHB

[Alisa Liu @alisawuffles]

I'm joining OpenAI next week!🥹 The job search turned out to be really challenging but also super rewarding, so I wrote a small blog to share what I learned along the way and hopefully make the process a little less mysterious for the next person. https://t.co/6FigSBdenD

[Tech with Mak @techNmak]

https://t.co/GV5Kg4P9gO

[Beybi Balina @BeybiBalina]

Sonunda denedim. Dehşet iyi.

Dün akşamdan beri çekirdeklerini çıkardığım hurmaları filtre kahve içinde dolapta bekletiyorum.

Sabah süzüp yoğurtla yedim. Ben tatlı olmasındansa yoğun olması için üstüne sadece tuz serptim.

Doyurucu, lüks bir tat.

(Sadece 3 hurmayı yedim 😅)

[Akshay 🚀 @akshay_pachaar]

Web scraping will never be the same.

(100% open-source visual search at scale)

PixelRAG is a retrieval system that skips HTML parsing completely.

Instead of scraping a page into text and embedding chunks, it screenshots the page and retrieves the image. A vision-language model reads the answer straight off the pixels.

Why that matters: parsing is where web RAG quietly loses information.

- A single HTML-to-text parser can drop 40%+ of a page.
- Tables, charts, and layout get flattened or thrown out.
- Swapping parsers alone can move accuracy ~10 points on the same docs.

PixelRAG indexes the page a person actually sees. The team built a visual index of all of Wikipedia, 30M+ screenshots, and it still beats the strongest text RAG baseline by 18.1% on text-only QA.

The repo also ships a Claude Code plugin that gives Claude eyes.

It lets Claude screenshot any URL and read the rendered page instead of scraping the DOM. So you can hand it a live page, an arXiv paper, or your local site and ask what it actually looks like.

One setup script. No MCP server, no backend.

How the pipeline works:

- Renders each document (web, PDF, image) to image tiles.
- Embeds them with Qwen3-VL-Embedding, LoRA fine-tuned on screenshots.
- Builds a FAISS index and serves a search API.

A stronger reader model lifts accuracy with no re-indexing, since the index is just pixels.

Everything is open-source under Apache-2.0.

GitHub repo: https://t.co/qun9TjAdmw

Talking about RAG, I recently wrote an article on a new approach that makes retrieval much more efficient by cutting corpus size by 40x, reducing tokens per query by 3x, and improving vector search relevance by 2.3x.

The article is quoted below.

[Anatoli Kopadze @AnatoliKopadze]

https://t.co/eq0oL4fIaR

[Bober_smart @Bober_smart]

https://t.co/p4teS18nnJ

[Codez @0xCodez]

https://t.co/nkojcYI4rS

[himanshu @retr0jirachi]

a really concise and cool blog on the current landscape of robotics i found recently and finished reading just now : https://t.co/WHS44mKf1B

[Dani @zaimiri]

https://t.co/a8ejOfyUQr

[Bryän @bryanonchain]

AI agent kamu nulis 80 baris code buat yang sebenarnya cuma butuh 1 baris?

Kenalan sama Ponytail plugin yang bikin AI coding agent berpikir seperti laziest senior dev di dunia.

"The best code is the code you never wrote."

Cara kerjanya:
1. Cek dulu: Apakah ini perlu? (YAGNI)
2. Sudah ada di stdlib?
3. Ada native feature di platform?
4. Sudah ada di dependency?
5. Bisa 1 baris?
6. Baru nulis code minimal

Hasil benchmark:
• 80–94% less code
• 47–77% cheaper
• 3–6× faster

Contoh:
❌ Agent nulis full date picker + library + wrapper + logic
✅ Ponytail: <input type="date"> <!-- ponytail: browser has one -->

Support: Hermes,Claude Code, Codex, Cursor, Antigravity, Pi Agent, OpenCode, dll.

Repo: https://t.co/EiEtlH22R9

Pasang sekarang & rasain bedanya. Agent kamu bakal jauh lebih "senior" (dan males nulis code berlebihan) 😂

Kamu sering kesal AI agent over-engineering?

Comment pengalamanmu 👇

[OpenRouter @OpenRouter]

Introducing the Fusion API, the smartest compound model in the market.

Fusion achieves Fable-level intelligence at half the price.

How it works 👇

[rody @0x_rody]

Anthropic's Claude Code engineer Sid Bidasaria:

"Stop babysitting your agents. If you're watching Claude work, you've already lost the leverage."

In 37 minutes, he shows how to set up agents that run without supervision, and the config below takes it to your phone.

Watch the talk, then grab the full setup below👇

[Thariq @trq212]

Lots of people asked how I used Fable to edit its own launch video so I made a video about that!

TLDR it wrote a lot of code &amp; tool calls to use transcription services, ffmpeg, do colorgrading, use the figma mcp, make remotion UI and render it.

I didn't touch a video editor.

[Peter Wang @BrainsAndTennis]

https://t.co/MVcIdCly31

[Codez @0xCodez]

Anthropic Managed Agents team:

"Fable 5 is our best model for running self-improving agent systems.

Add /loops, dynamic workflows, dreaming and you are unstoppable"

in 13-minutes, Anthropic team shows how to build self-improving agent systems with Fable 5 from scratch.

Worth more than a $500 agent building course.

Live from the last Anthropic stage in Japan. Unpublished.

[Mike Piccolo @mfpiccolo]

When I said, How to build your own agent harness? I truly meant it.

https://t.co/RemYB1SsFb is now live. It includes the exact components we use to build our harness, which are available for reuse.

Same engine and the same workers, swap as needed. Deploy to prod and scale as you wish.

[Dan Kornas @DanKornas]

Claude Code can drift when a task needs real judgment: debugging, architecture tradeoffs, risk analysis, or strategy.

Claude Code Thinking Skills is a library of 39 mental-model and critical-thinking skills for Claude Code users who want more structured reasoning.

It helps you route messy problems by starting with thinking-model-router, then invoking a named framework instead of relying on ad-hoc prompting.

Key features:
• 39 thinking skills – covers first principles, Bayesian reasoning, systems thinking, OODA, pre-mortem, TRIZ, and more.
• Router entry point – maps domain + problem type to a fitting framework.
• Claude Code native – each framework is packaged as a Claude Code skill you can invoke by name.
• Plugin install path – README shows Claude Code marketplace commands plus manual copy options.
• Transparent evals – publishes a replication-gated scorecard, including the current “zero robust replicated ELEVATE verdicts” result.

It’s open-source (MIT license).

Link in the reply 👇