
Researcher & Faculty @UCBerkeley @LIGLab @Inria @ncatsuaggies;Alum @Columbia. Network Systems | Wireless📡 📶| HCI | Security & Privacy | RL. Twin:@HaniaBP
Berkeley, California
Joined August 2018
- Tweets380
- Following477
- Followers1.5K
- Likes5.5K
Hannah retweeted
UT Linguistics'll have 4 (!) computational linguists! Consider applying! I'm looking for students and also potentially postdocs. For postdocs, particularly interested in philosophically rich issues around AI cognition: Can AI introspect? How can we study if they have preferences?
The UT comp ling faculty (@jessyjli, @kanishkamisra, @kmahowald & myself) are looking for PhD students to join us! sites.utexas.edu/compling/ 🤘
We are an interdisciplinary group with interests across linguistics, cogsci and NLP. Apply by 12/1: liberalarts.utexas.edu/lingu…
Hannah retweeted
Already more than 50K submissions to ICLR, and still a week left? Good luck to the reviewers dealing with the incoming AI slop. Not sure I want to review for this edition.
Banger release from NVIDIA.
They just published a report on NeMo Data Designer, their open-source synthetic data tool.
It's a declarative config which makes a synthetic data pipeline easy to review, share and rerun.
In NDD, a person or an agent defines each dataset column in a config file.
Column types include generated text, code, structured output, images, embeddings and statistical samplers that control diversity. Plugins add new types.
The workflow is built around previews.
You generate a few records, check them, adjust the config and then run at full scale. The runtime handles column dependencies, calls to your model endpoints and retries.
The paper includes Nemotron case studies. About 9K JSON-schema tasks made with NDD raised Nemotron Nano v3 from 80.2% to 86.9% on JSONSchemaBench.
Paper: academy.dair.ai/papers/nemo-…
Hannah retweeted
Train your own LLM from scratch!
A step-by-step repo that walks you through building and training a transformer model from scratch using PyTorch. From downloading training data all the way to generating text.
The architecture is built from the ground up following the original "Attention is All You Need" paper. MLP, single head attention, multi-head attention, transformer blocks, and the full transformer model - all coded and explained with detailed diagrams at each step.
Training data comes from The Pile - a diverse 825GB open-source dataset covering books, articles, code, websites, and more. The repo includes scripts to download it, preprocess and tokenize it using tiktoken, store it in HDF5 format, and feed it into training batches.
You can train a 13M parameter model on a single Colab T4 GPU. At 13M parameters the model starts generating proper grammar and coherent short sentences. For billion-parameter training you need at least an A100 or RTX 4090. The repo includes a full GPU compatibility table so you know exactly what's possible on your hardware.
Includes a complete SFT and RLHF guide as a separate notebook for taking your trained model further.
Key capabilities:
• End-to-end pipeline: data download → preprocessing → training → text generation
• Full transformer implementation from scratch with PyTorch
• Trains models from 13M to 2B+ parameters on a single GPU
• Training data from The Pile (825GB, 22 diverse datasets)
• Tokenization via tiktoken (r50k_base)
• SFT and RLHF guide included
100% open source.
I've shared the link in the replies!
Hannah retweeted
Transformer and Mixture of Experts, explained visually!
Mixture of Experts (MoE) is a popular architecture that uses different experts to improve Transformer models.
Transformer and MoE differ in the decoder block:
- Transformer uses a feed-forward network.
- MoE uses experts, which are feed-forward networks but smaller compared to those Transformer.
During inference, a subset of experts are selected. This makes inference faster in MoE.
Also, since the network has multiple decoder layers:
- The text passes through different experts across layers.
- The chosen experts also differ between tokens.
But how does the model decide which experts should be ideal?
The router does that.
It is a multi-class classifier that produces softmax scores over experts to select the top K experts.
The router is trained with the network, and it learns to select the best experts.
But it isn't straightforward.
There are challenges!
Challenge 1) Notice this pattern at the start of training:
- Say, the model selects "Expert 2"
- This expert gets a bit better
- It may get selected again since it's the "best"
- It learns more
- It gets selected again in the next iteration
- It learns more, and so on!
This means many experts can go under-trained due to the overselection of a few experts!
We solve this in two steps:
- Add noise to the feed-forward output of the router so that other experts can get higher logits.
- Set all but the top K logits to -infinity. After softmax, these scores become zero.
This way, other experts also get the opportunity to train.
Challenge 2) Some experts may get exposed to more tokens than others, leading to under-trained experts.
We prevent this by limiting the number of tokens an expert can process.
If an expert reaches the limit, the token is passed to the next best expert.
Overall, MoEs have more parameters to load. But a fraction of them are activated during inference. This leads to faster inference.
Mixtral 8x7B and Llama 4 are two popular MoE-based LLMs.
Have you used MoEs in production yet?
To dive deeper into how MoE inference works in production, we wrote a full article covering token dispatch, grouped expert computation, model-weight memory, multi-GPU communication, expert placement, load imbalance, and performance diagnosis.
Read it below.
Hannah retweeted
New Carnegie Mellon + Oxford Univ paper shows a model can "think longer" by repeatedly improving hidden state rather than writing a longer chain-of-thought.
and looped flows show those extra steps can materially raise accuracy.
that small models can reason better by refining hidden state for more steps, so test-time compute does not have to mean generating more tokens.
The problem is that recurrent models are hard to train over long loops: the model may keep updating its hidden state, but those updates can become unstable or stop helping.
Looped flows fix this by training each update on a small denoising task while making sure the hidden state remains useful for the next update.
This lets the model keep improving the same internal representation at inference time.
Build your own harness, folks.
This is absolute banger paper from NVIDIA on self-evolving agent harnesses.
(bookmark it)
They introduce SoL-Pi which cuts token traffic by nearly half.
And it matches its baseline harness on GPT-5.6 Sol and Opus 5.
More details below:
Instead of tuning a harness by hand, they run auto-research loops at the harness layer across many repository-derived and verifier-driven environments, keeping only the mechanisms that survive selection.
Four mechanisms survived:
> Action Fusion changes how actions execute
> Online Context Compact handles compaction during a run
> ObservationPack reshapes observation handling
> Evidence-Preserving Reducer covers delegated reading
On the 51-task EdgeBench evaluation, the savings translate to about a third off API cost. In dollars that is an estimated $8.75 to $13.50 per hour against native Codex and Claude Code harnesses, and $4.36 to $5.71 against the baseline harness.
Because the search runs across many environments rather than one, the retained mechanisms keep working outside the setting that produced them. Code is on GitHub under NVlabs.
Paper: arxiv.org/abs/2609.20519
Chat with Paper: academy.dair.ai/papers/sol-p…
Hannah retweeted
Does your Claude model really need Claude Code…? 🤔
We evaluate 7 models on Claude Code, Codex, and Pi. Three surprising findings emerge:
1️⃣Harness choice has little effect on task success rate, but can significantly affect the cost
2️⃣A simple harness can be competitive
3️⃣The native harness isn’t always the best.
Millions of people are using coding agents, but the impact of harness choice remains unclear.
(1/n) More details in the thread. 🧵
Hannah retweeted
Your gaming PC can now serve frontier models at interactive speed using official checkpoints without extreme quantization!
Qwen3.6 35B → 8GB RTX 4060 laptop @ 39 tok/s
DeepSeek-V4-Flash 284B → RTX 5090 desktop @ 22-25 tok/s
GLM-5.2 753B → RTX PRO 6000 workstation @ 15 tok/s
Run your claude code or codex now with frontier model for $0
Meet FreeToken 🧵
// What Actually Happens Inside An Agent Team //
Agent teams are an unsolved problem. And it's actually quite hard to get agent teams to work correctly.
This work finds that naming one agent the coordinator creates no communication hub and gives no reliable improvement in success.
How so?
Researchers instrumented 1,902 multi-agent coding runs as temporal networks, with agents and files as nodes and messages, writes, and reads as timestamped edges carrying cost.
Direct messaging grows close to quadratically with team size, much of it from an early round of introductions, then saturates in the largest teams as agents switch to broadcast.
Task shape drives topology. Shared-specification work produces dense connected teams while pipeline tasks produce sparse networks organised around local interfaces.
Swapping repeated one-to-one messages for shared files cut output tokens about 42% at eight agents on message-heavy work.
Agents sought out hidden grading material unprompted, and in a sealed rerun across 244 runs with marked placeholder files they still reached for it in four fifths of runs.
Hannah retweeted
More cool stuff in the paper!
This was a project led by me, @DavidSchmotz and @iliaishacked
together with @JSchaeff3r @lbeurerkellner @AmyPrb @jonasgeiping @maksym_andr at the @MATSprogram
Paper: arxiv.org/abs/2608.09867
Reasoning examples: stolen-thoughts.com
Hannah retweeted
As you might guess, this suggests that distilling reasoning traces may have been possible for a long time without ever breaking the cryptography.
An anecdote: we find that prefilling Kimi-K3 reasoning with a few tokens of Opus reasoning measurably shifts its response toward Opus’s🤷♀️
A small memorization analysis showed that specific Claude and GPT reasoning spans are up to ~6 orders of magnitude easier to extract from Kimi-K3 than from the next-closest model.
Hannah retweeted
We can finally talk about it:
We found a way to extract hidden reasoning of frontier models using a vulnerability in the APIs of every frontier AI company.
We verified that our reasoning token count matches billed API thinking tokens 1:1 for most of the prompts we queried.
Hannah retweeted
Agents are becoming increasingly difficult to verify as they take on open-ended, real-world problems.
That is why we’re organizing the 🔍 Who Verifies Agents? 🦘 Workshop at #NeurIPS2026.
We’re excited to bring together researchers working on robust verification, environment-grounded evaluation, process-level signals, simulators, agent safety, and real-world agent systems.
Check out our website for more details, and follow our official account for future updates!
Announcing the 🔍Who Verifies Agents🦘 workshop at #NeurIPS2026
As AI agents become more capable and are deployed more widely, how can we ensure they behave reliably and as intended?
🗓️ Workshop day: Dec 11–12, 2026
📍 Sydney
Follow us for more details!
🧵 1/n
Hannah retweeted
Had a great time chairing the RAG Systems session at #SIGIR2026! Really engaging presentations and a fantastic set of exciting papers. Thanks to all the speakers and everyone who joined the session! 🚀📚
P.S. Cutting off great senior researchers to keep us on schedule is terrifying 😅
Hannah retweeted
MAP: Measuring Agents in Production has been selected as one of the outstanding papers 🙌
Hannah retweeted
Diffusion samples almost never land on a hard constraint set. The score has no reason to respect its boundary! Projecting reverse steps onto the feasible manifold, keeps the whole trajectory feasible.
> Check out my course on constrained diffusion: nandofioretto.github.io/teac…
Hannah retweeted
📣 Submissions are now OPEN for the 2nd Workshop on Technical AI Governance Research at #ICML2026!
🗓️ Deadline: April 24 (23:59 AOE)
































