devanshu dixit

MS CS @VirginiaTech | Aspiring AI/ML Intern | Python | NLP | Founding Eng @sprectdotcom

[Emmy Liu @_emliu]

wrote a guide on getting compute grants as a student, something I wish I did more at the beginning of my PhD. It's honestly one of the highest ROI things you can do as a student (we've gotten 100k+ gpu hrs for roughly 2 weeks of work writing).

https://t.co/U15nwau88a

[Min Choi @minchoi]

This AI is pretty wild.

LingBot-Map can turn a live video stream into a 3D reconstruction in real time.

20 FPS

Code + Model 👇

[Tech with Mak @techNmak]

Here's the resource:

https://t.co/yFWSSTVzsl

[Alex Veremeyenko @alex_verem]

Zhejiang University researchers just taught AI models to compress and manage their own thinking in real time and the results completely change how we should think about reasoning costs.

The problem with modern reasoning models is brutal and getting worse.

Every time an AI like o1 or DeepSeek-R1 thinks through a complex problem, it generates thousands of tokens of intermediate reasoning.

That reasoning has to live somewhere.

For a model like Qwen-32B, once the context hits 10,000 tokens, the KV cache alone occupies as much memory as the entire model.

And the computational cost of attention grows quadratically with context length.

The longer the reasoning chain, the more expensive every single new token becomes.

This is the wall that reasoning models are hitting right now.

Most solutions try to work around it from the outside.

H2O evicts tokens based on attention scores.

SepLLM keeps tokens at punctuation marks.

These approaches reduce memory but add latency H2O actually makes inference 51-72% slower because it has to evaluate every token for eviction as it goes.

Zhejiang University took a different approach entirely.

Instead of pruning the context from the outside, they trained the model to manage its own memory from the inside.

The result is two systems they call LightThinker and LightThinker++.

LightThinker is the simpler version.

After each reasoning step, instead of keeping the full verbose thought in context, the model compresses it into a small set of special tokens just 7 to 9 tokens per thought and discards the original.

Reasoning continues from the compressed representation, not the raw text.

The model learns when to compress and how to compress through a custom attention mask design.

Think of it as the AI summarizing its own scratchpad after each step, keeping only the gist, and throwing away the rest.

Results for LightThinker on Qwen:
→ Peak token usage: -70%
→ Inference time: -26%
→ Accuracy drop: only 1%
→ Under same memory budget: 2.5x faster than baseline

That's meaningful.

A 70% reduction in peak memory with 1% accuracy loss at 2.5x the speed.

But the researchers found a limit.

When reasoning gets genuinely complex, irreversible compression becomes a problem.

Once a thought is compressed, the raw details are gone forever.

If the model needs to backtrack to a specific intermediate number or logical step, it can't.

They documented this failure directly: a model correctly computing 14,000 bars of chocolate during intermediate reasoning, then outputting 18,000 in the final answer because the compression step had dropped the number 8,000 mid-chain.

This is "information evaporation" and it's not a minor edge case.

It's a fundamental limitation of irreversible compression.

So they built LightThinker++.

Instead of compressing thoughts and discarding the originals permanently, LightThinker++ gives the model three explicit memory operations.

> commit: archive a reasoning step as a summary, but keep the raw version retrievable
> expand: pull a previously archived step back into full detail when you hit a logical bottleneck
> fold: compress it back after you've extracted what you needed

The model learns to use these operations autonomously.

> On simple tasks like MMLU, it mostly just commits and moves on.
> Only 5.8% of operations involve expand and fold.
> On hard reasoning tasks like GPQA, that number jumps to 21.5%.

The model is learning to recognize when it needs to look back.

LightThinker++ results:
→ Peak memory: -69.9% at same accuracy
→ Under strict context budget: +2.42% accuracy gain while still using 45% less memory
→ On GPQA specifically: +5.73% accuracy boost with 40.5% less peak memory
→ Compression ratio achieved: 15x on hard tasks, 8.6x on simpler ones

The counterintuitive finding: a compressed, high-signal context outperforms a verbose, unmanaged one.

More context isn't always better.

Noisy intermediate reasoning actually hurts model performance.

Removing the noise and keeping only the logical anchors lets the model attend more effectively to what actually matters.

The agentic results are where this gets genuinely alarming for anyone building AI research agents.

In long-horizon DeepResearch tasks where an agent browses the web across dozens of rounds the standard approach fails badly.

A vanilla agent's context inflates to approximately 100,000 tokens within 50-60 rounds.

At that point it suffers from lost-in-the-middle effects, starts hallucinating, and often stops prematurely not because it ran out of rounds but because the noise overwhelmed its reasoning.

LightThinker++ stays between 30,000 and 40,000 tokens even past 80 rounds.

That's a 60-70% reduction in active context maintained stably across the entire interaction.

Agentic benchmark results vs. standard SFT baseline:
→ xBench-DeepSearch: 38.3% → 44.0% Pass@1
→ BrowseComp-ZH: 31.5% → 36.9% Pass@1
→ BrowseComp-EN: 16.0% → 18.1% Pass@1
→ On hard instances that baseline almost always fails: 3x improvement in Pass@1
→ Reaches baseline's peak performance using 2.5x fewer search actions

The gap widens on harder tasks and longer interactions.

Standard agents plateau because information redundancy overwhelms them.

LightThinker++ keeps improving because it's actively distilling signal from noise at every step.

The model's reasoning lifespan is now governed by task complexity, not context explosion.

The deeper finding here is about what "thinking" actually costs.

The reasoning capability of models like o1 and DeepSeek-R1 comes from long chains of intermediate thought.

But those chains are full of linguistic padding, redundant recaps, and hedging language that serves fluency rather than logic.

LightThinker++ essentially strips out the fluency and keeps the logic.

And when it needs the fluency back to verify a specific step, it can retrieve it.

Then it folds it away again.

This is closer to how human working memory actually operates than anything prior approaches have achieved.

The implication for anyone running reasoning models at scale is direct.

The KV cache is currently one of the most expensive components in production deployment.

A 70% reduction in peak token usage isn't an efficiency gain — it's a cost structure change.

And the fact that accuracy improves under strict context budgets means the tradeoff isn't even a tradeoff.

Better reasoning. Lower cost. Smaller footprint.

[Yinghao Xu @YinghaoXu1]

🎉 After one year of teamwork, we are excited to release our 3D foundation model — LingBot-Map!

Unlike DA3/VGGT, LingBot-Map is a purely autoregressive model for streaming 3D reconstruction ⚡
It achieves ~20 FPS on 518×378 resolution over sequences exceeding 10,000 frames — and beyond 🚀

Two key insights behind LingBot-Map:
🔑 Keep SLAM's structural wisdom: build Geometric Context Attention with long-context modeling while maintaining a compact streaming state
🔑 Make everything end-to-end learnable — no optimization, no post-processing

Let's check out our demos 👇

[Yinghao Xu @YinghaoXu1]

📦 LingBot-Map is fully open-sourced — paper, code, models.

🔗 Project page: https://t.co/AGsve72ZWq
💻 Code: https://t.co/g9wtVElilA
📄 Paper: https://t.co/3CzniJ0ynt
🤗 HuggingFace: https://t.co/Jl71BsW4vz

[Akshay 🚀 @akshay_pachaar]

Google just solved an old RNN problem.

A new paper from Google Research introduces "Memory Caching," and the idea is almost too simple to believe.

Here's the problem it solves:

Modern RNNs compress the entire input into a single fixed-size memory state. As sequences get longer, old information gets overwritten. That's why they still struggle with recall-heavy tasks compared to Transformers.

Memory Caching addresses this by splitting the sequence into segments and saving the RNN's memory state at the end of each segment. When generating output, each token looks back at all these saved checkpoints, not just the current memory.

The complexity trade-off is elegant:

- Standard RNNs: O(L)
- Transformers: O(L²)
- Memory Caching: O(NL), where N = number of segments

You control the trade-off by choosing how many segments to cache. The model smoothly interpolates between RNN-like efficiency and Transformer-like recall.

The paper proposes four ways to use these cached memories:

1. Residual Memory: just sum all cached states (simplest)

2. Gated Residual Memory (GRM): input-dependent gates that weigh each segment's relevance to the current token

3. Memory Soup: interpolates the actual parameters of cached memories into a custom per-token network

4. Sparse Selective Caching (SSC): MoE-style routing that picks only the most relevant segments

Gated Residual Memory (GRM) consistently performs best across tasks.

Under simplifying assumptions, hybrid architectures that interleave RNN and attention layers can be viewed as a special case of Memory Caching. This gives clean intuition for why hybrid models work. They're implicitly caching memory states.

On recall-heavy tasks, Memory Caching significantly closes the gap between RNNs and Transformers. When applied to already strong models like Titans, it pushes them even further ahead on language understanding benchmarks.

Transformers still lead on the hardest retrieval tasks like UUID lookup at long contexts. But the direction is clear: you don't need to choose between fixed memory and quadratic attention. There's a useful middle ground now.

All experiments are at academic scale (up to 1.3B params). Whether these gains hold at frontier scale remains open. This comes from the same team behind Titans and MIRAS, so it's part of a larger research program on memory-augmented sequence models.

Paper: "Memory Caching: RNNs with Growing Memory" (Behrouz et al., 2026)

Link in the next tweet.

[Mingchen Zhuge @MingchenZhuge]

🫱 Introducing 𝐍𝐞𝐮𝐫𝐚𝐥 𝐂𝐨𝐦𝐩𝐮𝐭𝐞𝐫s:

𝐰𝐡𝐚𝐭 𝐢𝐟 𝐀𝐈 𝐝𝐨𝐞𝐬 𝐧𝐨𝐭 𝐣𝐮𝐬𝐭 𝐮𝐬𝐞 𝐜𝐨𝐦𝐩𝐮𝐭𝐞𝐫𝐬 𝐛𝐞𝐭𝐭𝐞𝐫, 𝐛𝐮𝐭 𝐛𝐞𝐠𝐢𝐧𝐬 𝐭𝐨 𝐛𝐞𝐜𝐨𝐦𝐞 𝐭𝐡𝐞 𝐫𝐮𝐧𝐧𝐢𝐧𝐠 𝐜𝐨𝐦𝐩𝐮𝐭𝐞𝐫 𝐢𝐭𝐬𝐞𝐥𝐟?

Beyond today's conventional computers, agents, and world models, Neural Computers (NCs) are new frontiers where computation, memory, and I/O move into a learned runtime state.

We ask: whether parts of runtime can move inward into the learning system itself. This is our first step toward the Completely Neural Computer (CNC): a general-purpose neural computer with stable execution, explicit reprogramming, and durable capability reuse.

Work done with Mingchen Zhuge (@MingchenZhuge), Changsheng Zhao, Haozhe Liu (@HaoZhe65347 ), Zijian Zhou (@ZijianZhou524 ), Shuming Liu (@shuming96 ), Wenyi Wang (@Wenyi_AI_Wang ), Ernie Chang (@erniecyc ), Gael Le Lan, Junjie Fei, Wenxuan Zhang, Zhipeng Cai (@cai_zhipeng ), Zechun Liu (@zechunliu ), Yunyang Xiong (@YoungXiong1 ), Yining Yang, Yuandong Tian (@tydsh ), Yangyang Shi, Vikas Chandra (@vikasc), Juergen Schmidhuber (@SchmidhuberAI)

[Abhinav Upadhyay @abhi9u]

@krismicinski Something like this? https://t.co/iagOdse3qd, not specifically reasoning models though.

[Andrej Karpathy @karpathy]

Yes it's the tractable form of brain upload. There's a ton of scifi on brain uploads that requires way too exotic tech (scanning and simulating brains etc), when we're about to get a lossy and approximate version of that *a lot* sooner via LLM simulators. You can easily imagine a "brain upload" startup - you show up for a few days to carry out detailed video interviews, then they use all that data with an LLM finetuning process to "upload" you and give you an API endpoint of your simulation that you can talk to. Look at what's already possible with HeyGen as an example, but combine it with an LLM model that has deep knowledge and personality. Trippy and admittedly kind of dystopian but in principle quite possible around now.

[elvis @omarsar0]

NEW paper from Meta.

(bookmark this one)

What if the model wasn't just using the computer, but became the computer?

New research from Meta AI and KAUST makes a serious case for Neural Computers (NCs).

The paper proposes NCs as learned runtimes where computation, memory, and I/O live inside a single latent state. Their first prototypes use video models to roll out terminal and GUI interfaces from prompts, pixels, and user actions.

Why does it matter?

Today's agents still depend on external computers to store state, execute actions, and enforce system contracts. Neural Computers point to a different machine form: one where interface dynamics, working memory, and execution are learned together.

The early results are promising but grounded. CLI rendering improves, GUI cursor control reaches 98.7% with explicit visual supervision, and reprompting boosts arithmetic-probe accuracy from 4% to 83%. But symbolic reliability, stable reuse, and runtime governance remain open.

This is less "agents got better" and more "what comes after agents as a computing substrate?"

Paper: https://t.co/CKdclokmer

Learn to build effective AI agents in our academy: https://t.co/1e8RZKs4uX

[Ihtesham Ali @ihteshamali]

holy shit.

Someone turned Andrej Karpathy's X thread complaints into a file that fixes Claude Code.

It's called andrej-karpathy-skills.

One CLAUDE.md. Four principles. The exact four problems Karpathy called out wrong assumptions, bloated code, orthogonal edits, vague task loops each one has a specific rule that shuts it down before it happens.

You install it in 10 seconds and your diffs start looking like what you actually asked for.

https://t.co/BYsyYlgoIh

[Ihtesham Ali @ihteshamali]

I set this up at 4am and spent an hour just talking to it.

It's called Open-LLM-VTuber. You get a Live2D animated AI companion that runs completely offline, sees your screen, hears your voice, and never forgets your conversations.

The voice interruption system is different from anything I've seen. The AI cannot hear its own TTS output so there is zero feedback loop and zero awkward pauses. It feels like a real conversation.

The inner thoughts feature floored me. You see what the AI is thinking as a separate text layer that never gets spoken. You watch the reasoning happen in real time before the words come out.

Pet mode puts the avatar on your desktop as a transparent overlay that floats above every window without blocking anything. Drag it anywhere. It follows you.

The persona is entirely yours. Import any Live2D model. Write any system prompt. Clone any voice. Swap the entire LLM backend from Ollama to Claude to DeepSeek in a single config line.

100,000+ conversations have already happened inside this repo according to the user reviews.

That number is going to keep moving.

https://t.co/36hRUqNzhu

6.1K stars. MIT License. 100% Opensource.

What would you use this for... co-working, learning, coding, or just chaos?

[Ihtesham Ali @ihteshamali]

A professor quit a high-paying consulting job to teach math to seventh graders in a New York public school, and what she saw in that classroom launched the most important research on human achievement of the last 30 years.

Her name is Angela Duckworth, and the question that haunted her from day one was deceptively simple: why do some kids succeed and others don't?

It wasn't IQ. She could see that immediately. Some of her sharpest students were underperforming. Some of her slowest were grinding past everyone else. The variable she couldn't name was right in front of her face and it took her a decade of research at Penn and Stanford to finally pin it down.

Here is what she found, and why it should change how you think about every hard thing you are trying to build.

She started by going back to a famous experiment from the late 1960s. A Stanford psychologist named Walter Mischel brought four-year-olds into a small room one at a time, placed a marshmallow in front of them, and told them he had to leave. If they waited until he returned, they'd get two marshmallows. If they couldn't wait, they could ring a bell and eat the one in front of them right now.

Most kids lasted about thirty seconds.

But what happened over the next decade is what made Mischel's study famous. When he tracked those same children down years later, the ones who had waited the longest had SAT scores 210 points higher on average than the ones who rang the bell immediately. Self-control at age four predicted academic outcomes that most educators couldn't explain even after years of watching the kids up close.

Duckworth was fascinated but she was after something deeper. Self-control explained part of the picture. It didn't explain everything. She thought about her own career early, scattered, unfocused by her own admission and compared it to people she knew who had found a mission at twenty-two and never let go of it. They weren't smarter than her. They weren't working harder than her in any obvious sense.

They had something else.

She called it grit. And the definition matters, because the word has been diluted into a motivational poster cliché that misses the point entirely.

Grit, in Duckworth's framework, is not toughness. It is not working long hours. It is not refusing to quit when things get hard, although that is part of it. Grit is the combination of passion and persistence aimed at a single long-term goal over years and sometimes decades. The passion part is often misunderstood. She does not mean excitement or enthusiasm. She means the sustained fascination with a specific problem. The thing you keep returning to even when you don't have to.

She built a twelve-question test to measure it. The Grit Scale. And then she took it into the field.

At the University of Pennsylvania, students with high grit scores earned higher GPAs than their peers, even when those peers had entered college with stronger test scores. At the National Spelling Bee, grit scores predicted which children survived to the later rounds more accurately than hours of practice alone. But the finding that stopped the room every time she presented it came from West Point.

Every year, West Point runs thousands of incoming cadets through a brutal summer training course called Beast Barracks. The military had developed its own complex evaluation tool called the whole candidate score to predict who would make it through. It factored in academic grades, physical fitness, leadership potential. Admissions teams had been refining it for years.

Duckworth gave her twelve-question grit test to over twelve hundred cadets as they arrived.

Her test outpredicted the whole candidate score.

The cadets who dropped out weren't the weakest physically or the least intelligent academically. They were the ones who scored lowest on passion and persistence toward a long-term goal. The ones who made it through were the ones who had a reason to be there that was bigger than any single difficult day.

The finding that most people miss when they hear about this research is the distinction Duckworth draws between motivation and volition.

Motivation is wanting something. Volition is the ability to keep moving toward it when the wanting isn't strong enough to carry you on its own. You can be extremely motivated to build something and still quit at the first serious obstacle because you never developed the second thing. The marshmallow kids who waited the longest weren't the ones who wanted two marshmallows more desperately. They were the ones who had learned to redirect their attention, to think abstractly about the goal, to make the immediate discomfort feel smaller than the long-term payoff.

That skill is trainable. That is the part that almost never makes it into the summary.

Duckworth's research shows grit is only faintly related to IQ. There are brilliant people with almost no grit and ordinary people with extraordinary amounts of it. The raw intelligence gets you to the starting line. What happens after that is almost entirely determined by whether you have the combination of a goal worth caring about for years and the discipline to keep working toward it on the days when nothing is going well.

Her TED Talk on this has been watched over 17 million times, which means the idea has clearly landed somewhere real in people. But the part that usually gets quoted is the definition. The part that actually matters is harder to talk about.

You cannot manufacture grit by deciding to be grittier. What you can do is find the problem you are genuinely willing to be obsessed with for a decade. Not excited about. Obsessed with. And then build the systems around that obsession that make daily persistence the default, not the exception.

The marshmallow test did not sort brave children from cowardly ones. It sorted children who had already learned that discomfort is temporary from children who hadn't learned that yet.

Every gritty person you have ever admired figured out one thing the rest of the room hadn't: the goal on the other side of the hard stretch is more real to them than the discomfort standing between them and it.

That is not a personality type. That is a decision, made early and remade every day.

[Farza 🇵🇰🇺🇸 @FarzaTV]

This is Farzapedia.

I had an LLM take 2,500 entries from my diary, Apple Notes, and some iMessage convos to create a personal Wikipedia for me.

It made 400 detailed articles for my friends, my startups, research areas, and even my favorite animes and their impact on me complete with backlinks.

But, this Wiki was not built for me! I built it for my agent!

The structure of the wiki files and how it's all backlinked is very easily crawlable by any agent + makes it a truly useful knowledge base.

I can spin up Claude Code on the wiki and starting at index.md (a catalog of all my articles) the agent does a really good job at drilling into the specific pages on my wiki it needs context on when I have a query.

For example, when trying to cook up a new landing page I may ask:

"I'm trying to design this landing page for a new idea I have. Please look into the images and films that inspired me recently and give me ideas for new copy and aesthetics".

In my diary I kept track of everything from: learnings, people, inspo, interesting links, images.

So the agent reads my wiki and pulls up my "Philosophy" articles from notes on a Studio Ghibli documentary, "Competitor" articles with YC companies whose landing pages I screenshotted, and pics of 1970s Beatles merch I saved years ago. And it delivers a great answer.

I built a similar system to this a year ago with RAG but it was ass.

A knowledge base that lets an agent find what it needs via a file system it actually understands just works better.

The most magical thing now is as I add new things to my wiki (articles, images of inspo, meeting notes) the system will likely update 2-3 different articles where it feels that context belongs, or, just creates a new article.

It's like this super genius librarian for your brain that's always filing stuff for your perfectly and also let's you easily query the knowledge for tasks useful to you (ex. design, product, writing, etc) and it never gets tired.

I might spend next week productizing this, if that's of interest to you DM me + tell me your usecase!

[Andrej Karpathy @karpathy]

LLM Knowledge Bases

Something I'm finding very useful recently: using LLMs to build personal knowledge bases for various topics of research interest. In this way, a large fraction of my recent token throughput is going less into manipulating code, and more into manipulating knowledge (stored as markdown and images). The latest LLMs are quite good at it. So:

Data ingest:
I index source documents (articles, papers, repos, datasets, images, etc.) into a raw/ directory, then I use an LLM to incrementally "compile" a wiki, which is just a collection of .md files in a directory structure. The wiki includes summaries of all the data in raw/, backlinks, and then it categorizes data into concepts, writes articles for them, and links them all. To convert web articles into .md files I like to use the Obsidian Web Clipper extension, and then I also use a hotkey to download all the related images to local so that my LLM can easily reference them.

IDE:
I use Obsidian as the IDE "frontend" where I can view the raw data, the the compiled wiki, and the derived visualizations. Important to note that the LLM writes and maintains all of the data of the wiki, I rarely touch it directly. I've played with a few Obsidian plugins to render and view data in other ways (e.g. Marp for slides).

Q&A:
Where things get interesting is that once your wiki is big enough (e.g. mine on some recent research is ~100 articles and ~400K words), you can ask your LLM agent all kinds of complex questions against the wiki, and it will go off, research the answers, etc. I thought I had to reach for fancy RAG, but the LLM has been pretty good about auto-maintaining index files and brief summaries of all the documents and it reads all the important related data fairly easily at this ~small scale.

Output:
Instead of getting answers in text/terminal, I like to have it render markdown files for me, or slide shows (Marp format), or matplotlib images, all of which I then view again in Obsidian. You can imagine many other visual output formats depending on the query. Often, I end up "filing" the outputs back into the wiki to enhance it for further queries. So my own explorations and queries always "add up" in the knowledge base.

Linting:
I've run some LLM "health checks" over the wiki to e.g. find inconsistent data, impute missing data (with web searchers), find interesting connections for new article candidates, etc., to incrementally clean up the wiki and enhance its overall data integrity. The LLMs are quite good at suggesting further questions to ask and look into.

Extra tools:
I find myself developing additional tools to process the data, e.g. I vibe coded a small and naive search engine over the wiki, which I both use directly (in a web ui), but more often I want to hand it off to an LLM via CLI as a tool for larger queries.

Further explorations:
As the repo grows, the natural desire is to also think about synthetic data generation + finetuning to have your LLM "know" the data in its weights instead of just context windows.

TLDR: raw data from a given number of sources is collected, then compiled by an LLM into a .md wiki, then operated on by various CLIs by the LLM to do Q&A and to incrementally enhance the wiki, and all of it viewable in Obsidian. You rarely ever write or edit the wiki manually, it's the domain of the LLM. I think there is room here for an incredible new product instead of a hacky collection of scripts.

[Ihtesham Ali @ihteshamali]

https://t.co/fzmhIFsR7f

[Eddy Xu @eddybuild]

today, we're releasing the largest egocentric dataset of physical jobs

- 400k action labels
- 2.5k clips
- 2x'd open source dataset size

(download below)

[David Aerne @meodai]

Just entered the dangerous realm of custom cursors… there’s no turning back now

[Hardeep @hardeep_gambhir]

mf cooked here ong