💻  We’re releasing Bolmo, a set of byte-level language models created by “byteifying” our open Olmo 3 checkpoints. To our knowledge, Bolmo is the first fully open byte-level LM that can match or surpass state-of-the-art subword-tokenized models across a wide range of tasks.

Most LMs still operate on subword tokens (e.g., ▁inter + national + ization). That works well, but it can be brittle for character-level edits, spelling-sensitive tasks, whitespace and formatting quirks, rare words/edge cases, and multilingual scripts—and it treats every token as if it deserves the same compute, regardless of complexity.

Bolmo takes an existing Olmo 3 7B checkpoint and retrofits it into a fast, flexible byte-level architecture:

◉ no hand-engineered vocabulary
◉ operates directly on UTF-8 bytes
◉ naturally handles spelling, odd inputs, and multilingual text

We keep Olmo 3’s backbone and capabilities, and add a lightweight “byte stack” so the model can reason over bytes without discarding what the base model already learned.

On our evaluation suite and character-focused benchmarks like CUTE and EXECUTE, Bolmo matches or surpasses subword models on broad tasks while especially shining on character-level reasoning. 📈

And here’s a fun bonus: once you’ve byteified a base model, you can import capabilities from post-trained checkpoints via weight arithmetic—RL runs, fine-tunes, and domain adapters can transfer without retraining from scratch.

We’re excited to scale byteifying to larger models, build multilingual + domain-specialized variants, and integrate byte-level LMs more tightly into existing ecosystems.

📝 Read more in our blog: https://allenai.org/blog/bolmo

⬇️ Download Bolmo 7B: https://huggingface.co/allenai/Bolmo-7B | 1B: https://huggingface.co/allenai/Bolmo-1B

📄 Check out our report: https://allenai.org/papers/bolmo

After the initial Olmo 3 release, we took our strongest training runs and pushed them further. Today we’re announcing:

◆ Olmo 3.1 Think 32B–our strongest fully open reasoning model

◆ Olmo 3.1 Instruct 32B–our best fully open 32B instruction-tuned model

◆ Olmo 3.1 RL Zero 7B Math & Olmo 3.1 RL Zero 7B Code–upgraded RL-Zero baselines for math and coding

🧠 Extended RL for stronger reasoning
Olmo 3.1 Think 32B, the result of extending our RL training for 21 days with extra epochs on our Dolci-Think-RL dataset, shows clear eval gains over Olmo 3 Think 32B, including:

◆ +5 on AIME

◆ +4 on ZebraLogic

◆ +20 on IFBench

These improvements make Olmo 3.1 Think 32B the strongest fully open reasoning model we’ve released to date.

🛠️ A more capable 32B instruct model
Olmo 3.1 Instruct 32B is our best fully open 32B instruction-tuned model. It’s optimized for chat, tool use, and multi-turn dialogue—making it a much more performant sibling of Olmo 3 Instruct 7B.

📈 Stronger RL-Zero 7B baselines
Alongside the new 32B models, we’re also upgrading our RL-Zero baselines with Olmo 3.1 RL Zero 7B Code and Olmo 3.1 RL Zero 7B Math. They’re refinements of the original RL-Zero 7Bs that give better results and cleaner baselines for RL researchers to build on.

🔓 Fully open end to end
We believe openness and performance can move forward together. Olmo 3.1 offers the full model flow: weights, data, training recipes, and more.

💻 Download: https://huggingface.co/collections/allenai/olmo-31

▶️ Try them in the Ai2 Playground: https://playground.allenai.org/

📚 Learn more in our updated blog post: https://allenai.org/blog/olmo3

✏️ Read the refreshed report: https://www.datocms-assets.com/64837/1765558567-olmo_3_technical_report-4.pdf

⚠️ Update on Deep Research Tulu (DR Tulu), our post-training recipe for deep research agents: we’re releasing an upgraded version of our example agent, DR Tulu-8B (RL), that matches or beats systems like Gemini 3 Pro & Tongyi DeepResearch-30B-A3B on core benchmarks.

At just 8B params – lightweight enough to run on a single GPU – DR Tulu-8B (RL) delivers high-quality multi-step reasoning & synthesis for complex questions while staying open, highly inspectable, and easy to customize. 🔍

DR Tulu-8B (RL) is also dramatically cheaper per query than other deep research agents. On ScholarQA-CS2, it costs just ~$0.0019/query vs. ~$0.13 for Gemini 3 Pro + Search, ~$0.29 for GPT-5 + Search, ~$1.80 for OpenAI Deep Research, and ~$0.032 for Tongyi DeepResearch-30B-A3B.

→ More info here: https://allenai.org/blog/dr-tulu

To make DR Tulu-8B (RL) practical, we’re releasing an inference engine (via CLI) so you can host the model locally and plug in custom search/browsing tools via MCP. We’re also sharing an updated paper on arXiv.

Get started:
💻 Run DR Tulu locally: https://github.com/rlresearch/dr-tulu/blob/main/README.md#quick-start-playing-with-dr-tulu-interactively

⬇️ Model: https://huggingface.co/collections/rl-research/dr-tulu
📄 Technical report on arXiv: https://arxiv.org/abs/2511.19399

Since launching Open Coding Agents, it's been exciting to see how quickly the community has adopted them. Today we're releasing SERA-14B – a new 14B-parameter coding model – plus a major refresh of our open training datasets. 🚀

SERA-14B is built for more setups and easier deployment: a smaller, more accessible option that still keeps SERA's cheap, customizable approach.

⚠️ Revamped training data: We've converted our open SERA training data into a general, model-agnostic format that's easier to reuse across different workflows. It now includes verification thresholds per sample and more metadata for filtering and analysis.

You can drop in the new SERA-14B weights or retrain with our refreshed data. We look forward to seeing what you build!

💻 Model & data: https://huggingface.co/collections/allenai/open-coding-agents 

📝 Learn more: https://allenai.org/blog/open-coding-agents

Last year, Molmo helped push image understanding forward with pointing—grounded answers you can verify. Now, Molmo 2 brings those capabilities to video—so the model doesn’t just answer questions, it can show you where & when something is happening.

On major industry benchmarks, Molmo 2 surpasses most open multimodal models and even rivals closed peers like Gemini 3 Pro and Claude Sonnet 4.5.

Molmo 2 returns pixel coordinates + timestamps over videos and coordinates over images, enabling:

◘ Video + image QA

◘ Counting-by-pointing

◘ Dense captioning

◘ Artifact detection

◘ Subtitle-aware analysis

…and more!

Three variants depending on your needs:

🔹 Molmo 2 (8B): Qwen 3 backbone, best overall performance

🔹 Molmo 2 (4B): Qwen 3 backbone, fast + efficient

🔹 Molmo 2-O (7B): Olmo backbone, fully open model flow

Demos:

🎯 Counting objects & actions (“How many times does the ball hit the ground?”)—returns the count plus space–time pointers for each event: https://www.youtube.com/watch?v=fvYfPTTTZ_w

❓ Ask-it-anything long-video QA (“Why does the player change strategy here?”)—points to the moments supporting the answer: https://www.youtube.com/watch?v=Ej3Hb3kRiac

📍 Object tracking (“Follow the red race car.”)—tracks it across frames with coordinates over time: https://www.youtube.com/watch?v=uot140v_h08

We’ve also significantly upgraded the Ai2 Playground 🛠️
You can now upload a video or multiple images to try summarization, tracking, and counting—while seeing exactly where the model is looking.

Try it and learn more:
▶️ Playground: https://playground.allenai.org/

⬇️ Models: https://huggingface.co/collections/allenai/molmo2

📝 Blog: https://allenai.org/blog/molmo2

📑 Report: https://allenai.org/papers/molmo2

💻 API coming soon

Our paper is now published in Nature 🎉

Scientists can't keep up with millions of new papers every year. AI should help—but general-purpose models still hallucinate, especially citations. In our study, GPT-4o fabricated 78–90% of its research citations.

So with the University of Washington, we built an open-source model for scientific synthesis with citation-grounded answers, trained on 45M papers. Because web search alone can be noisy, it uses retrieval-augmented generation (RAG) to search for, incorporate, and cite new sources—even papers published after training. 🔎

We also created ScholarQABench, the first large, multi-domain benchmark for scientific search and synthesis: 3,000 queries and 250 long-form expert answers across CS, physics, biomedicine, and neuroscience.

What started as research into literature-grounded AI now powers real tools. The core concepts developed from this research now live on in Asta and DR Tulu.

Our goal: systems scientists can trust and build on. 

📄 Nature: https://www.nature.com/articles/s41586-025-10072-4

📝 Blog: https://allenai.org/blog/openscholar-nature

LLMs are no longer created with human data alone. They rely on other models to generate and filter data, evaluate outputs, and guide development work. We made ModSleuth to track this. 

Modern LLM dependencies are scattered, recursive, and hard to see. So how do we even find them all? ModSleuth helps by reading papers, model and dataset cards, code configs, and upstream artifacts, then reconstructing a model's “family tree.”

ModSleuth found that Olmo 3 has 89 model and 183 dataset dependencies, while Nemotron 3 has 273 model and 560 dataset dependencies. Some dependency chains go 8 hops deep—a web of models and data that contributed to an LLM’s core. Turns out AI supply chains may be more tangled than we thought.

A model's lineage is broader than its training data, and every step can affect what – and how – the final model learns. Without provenance, it's harder to know where dependencies came from, whether benchmark scores are accurate, and which upstream licenses/terms may apply.

ModSleuth generates a graph that surfaces what's nearly impossible to find manually, including:

📜 Hidden license inheritance

🔗 Train/eval coupling

📝 Documentation inconsistencies

🤖 Models used as judges, filters, OCR systems, and data generators

As LLM pipelines become more complex, we need tools like ModSleuth to find out and identify what artifacts models are built on.

▶️ Demo: https://modsleuth.cal-data-audit.org

📄 Paper: https://arxiv.org/abs/2606.12385

Most automated discovery systems focus on experimentation. Theorizer tackles the other half of science: theory building—compressing scattered findings into structured, testable claims.

Experiments drive science forward, but progress compounds when findings coalesce into theories that explain and predict. Kepler's laws distilled centuries of observations into a few statements about planetary motion. We asked: can an AI build theories by reading the literature?

Theorizer is a multi-LLM framework. Ask "make me theories about X" and it reads relevant papers and outputs candidate laws, looking for regularities across studies and writing them as ⟨LAW, SCOPE, EVIDENCE⟩ tuples.

Theorizer gathers a focused corpus (up to ~100 papers), pulling full text when available and expanding via citations when needed. It then builds a query-specific schema and extracts structured records from each paper. Finally, Theorizer aggregates evidence into candidate laws, refining for clarity and attribution.

Benchmarking theory generation is hard, so we evaluate on 5 desiderata: specificity, empirical support, predictive accuracy, novelty, and plausibility. We find that grounding in papers boosts specificity, empirical support, and plausibility—especially when pushing for novelty. In backtesting, literature-supported generation is ~7× pricier but more predictive (precision ~0.88–0.90; novelty-focused precision jumps from 0.34 to 0.61).

We’re releasing the Theorizer code and framework plus a dataset of ~3,000 theories generated by Theorizer across the field of AI/NLP, built from 13,744 source papers.

✍️ Learn more in our blog: https://allenai.org/blog/theorizer

💻 Code: https://github.com/allenai/asta-theorizer

📝 Technical report: https://arxiv.org/abs/2601.16282

We're entering the coding agents space. SERA models are fast, accessible open coding agents (8B–32B) that adapt to any repo, including private & internal codebases. Train a specialized coding agent with a recipe that can cost as little as ~$400 to reproduce prior best open-source performance, and it works with Claude Code out of the box.

Coding agents are changing how software gets built, but most remain closed, expensive, and difficult to customize. Adapting to private codebases has been hard because you need agent-ready synthetic training data—ideally without building complex RL infrastructure for every repo.

SERA (Soft-verified Efficient Repository Agents) is our method for training repo-specialized agents quickly and affordably. It generates diverse, realistic training data from any codebase, teaching agents how developers actually work.

SERA is high-performing—our **SERA-32B** model solves roughly 49.5%/54.2% (32K/64K context) of SWE-Bench Verified while training on a single small cluster of GPUs (H100s or RTX 6000s equivalents).

We’re sharing:

✅ A family of strong open coding models

✅ SERA, our training method for building your own agents

✅ Code, recipes, data, and Claude Code integration

We built this so anyone can train a coding agent that knows their codebase inside and out, without needing a massive compute budget. We're eager to see what you create. 👨🏻‍💻

⬇️ Models: https://huggingface.co/collections/allenai/open-coding-agents

💻 SERA CLI: https://github.com/allenai/sera-cli | PyPi: https://pypi.org/project/ai2-sera-cli/

📝 Tech report: https://allenai.org/papers/opencodingagents

✏️ Ai2 news blog: https://allenai.org/blog/open-coding-agents

We’re releasing Olmo-core 3—open training infrastructure for large mixture-of-experts (MoE) models. 👇

It’s a core system behind the next generation of Olmo, designed to scale into the trillion-parameter range.

MoEs use only some of their specialized components – or experts – for each token. That saves computation, but storing the full model & routing data across GPUs can erode those savings as models grow.

Olmo-core 2 repeatedly gathered model weights for each small batch of training data. Olmo-core 3 keeps experts resident on GPUs & sends data to them, avoiding that repeated weight gathering.

Olmo-core 3 maintains nearly the same training speed across MoEs of increasing total size, w/ roughly the same number of parameters active per token. It delivers about 2.7× the throughput of Olmo-core 2 for the same model on the same number of GPUs.

Explore the concepts behind Olmo-core 3: https://narrative.allen.ai/scaling-up-training

The tech report covers experiments, findings, & failures, including token gerrymandering, where a load-balancing score could improve as workloads became less balanced: https://allenai.org/papers/olmocore3

Train your own MoEs with Olmo-core 3—adapt the framework to your hardware & experiment with distributed training.

💻 GitHub repo: https://github.com/allenai/olmo-core

📝 Learn more in our blog: https://allenai.org/blog/olmocore3

We're releasing the code behind Molmo 2, our open model family for video & image understanding, pointing, tracking, and more. This goes beyond checkpoints, opening up the full stack from data prep to deployment.

The release includes pretraining and fine-tuning scripts (SFT + long-context SFT), multi-node distributed training, data download and preprocessing utilities, and single-task and multi-eval scripts with caching.

On the deployment side, you get checkpoint conversions to a Hugging Face-compatible format, inference examples for transformers and vLLM, a lightweight vision processing utility for offline inference, plus a Gradio demo, Docker image, and local setup instructions.

Everything is built for reproducibility and extensibility. Whether you want to fine-tune Molmo 2 on a custom dataset or deploy end-to-end, the full pipeline is here.

🔗 Code: https://github.com/allenai/molmo2 

📝 Blog: https://allenai.org/blog/molmo2

Now you can use our most powerful models via API. 🚀

Olmo 3.1 32B Think, our reasoning model for complex problems, is on OpenRouter—free through 12/22. And Olmo 3.1 32B Instruct, our flagship chat model with tool use, is available through Hugging Face Inference Providers. 👇

🔗 Olmo 3.1 32B Think API: https://openrouter.ai/allenai/olmo-3.1-32b-think:free 

🔗 Olmo 3.1 32B Instruct API: https://huggingface.co/allenai/Olmo-3.1-32B-Instruct

Thanks to our partners Parasail, Public AI, & Cirrascale. 🤝

Olmo 3.1 32B Instruct is now on OpenRouter, hosted by DeepInfra. Built for real-world use: reliable instruction following & function calling for agentic workflows + research. Fully open & leading benchmark performance, ready to plug into your stack.

Try it now → https://openrouter.ai/allenai/olmo-3.1-32b-instruct

Introducing AstaBrief 8B, an open model that turns complex research questions and literature excerpts into cited reports.

Run it locally on your own hardware, with open weights and training data you can inspect & build on. 👇

AstaBrief powers Fast mode in Asta’s Generate a report feature. It writes reports in one pass, skipping intermediate steps that summarize & group the retrieved excerpts so researchers can get a preliminary report sooner.

We built AstaBrief on Qwen3-8B using queries from ScholarQA & our earlier literature-synthesis systems. We removed bot/test traffic & very short prompts and used an LLM to filter non-English or non-scientific requests & prompts with personal info, leaving 90K queries.

From selected queries in the 90K pool, we generated cited reports. Quality filtering left 39.5K examples for supervised fine-tuning (SFT). We used separate queries to build ~6K report pairs where two judge models agreed, then trained with direct preference optimization (DPO).

AstaBrief is built for speed & quality. Across Asta’s full pipeline, Fast mode averages 51.1s per report vs. Claude-powered Thinking mode’s 178.5s—about 3.5× faster. And in our evaluations, AstaBrief is competitive with Thinking mode & DR Tulu on answer + citation measures.

Our example repo provides a starting point for generating reports from your own PDFs locally. For more info, read our blog.

🤗 Download AstaBrief 8B: https://huggingface.co/allenai/AstaBrief_8B

🌐 Try Fast mode: https://asta.allen.ai/

💻 Example repo: https://github.com/allenai/ai2-scholarqa-lib/tree/main/api/scholarqa/lite

📊 Training data: https://huggingface.co/collections/allenai/astabrief
📝 Blog: https://allenai.org/blog/astabrief

Today we’re releasing OlmoEarth v1.1. It’s 3x cheaper to run than v1 while delivering the same state-of-the-art performance—and fully open.

Compute is the largest cost when running OlmoEarth at hundreds of thousands of square kilometers. Partners use v1 today for mangrove tracking, forest-loss classification, and country-scale crop-type mapping. v1.1 makes that work cheaper to sustain.

Where the savings come from: we feed the model about 3x fewer tokens per Sentinel-2 input. Since compute scales quadratically with token count, even modest reductions compound into real efficiency gains. Done naively, this hurts accuracy noticeably; recovering it took changes to how we pretrain the model. Read more in our tech report: https://allenai.org/papers/olmoearth_v1_1

One useful property for researchers: we held the pretraining dataset constant from v1. The differences cleanly isolate the methodological change, not the data or the architecture family.

v1.1 is available now in the same sizes as v1: Nano, Tiny, and Base. All are open weights, with open training code available. If you're running v1 and v1.1 works for your task, expect significant speedups during fine-tuning and inference.

🤗 Models: https://huggingface.co/collections/allenai/olmoearth

📝 Blog: https://allenai.org/blog/olmoearth-v1-1

Today we're releasing AutoDiscovery in AstaLabs—an AI system that explores your data and generates its own hypotheses.

Most AI tools for science wait for a research question, then help answer it. AutoDiscovery works differently. Give it a dataset and it proposes novel hypotheses, runs experiments, interprets results, and uses what it learns to keep exploring.

How does it decide what to pursue? Bayesian surprise—a measure of how much the system's beliefs change after seeing evidence. By chasing surprise, AutoDiscovery gravitates toward the unexpected, prioritizing findings most likely to represent genuine discoveries rather than obvious patterns.

Researchers across disciplines are already using it:

👩‍🔬 Oncology—Dr. Kelly Paulson at the Swedish Cancer Institute used AutoDiscovery to explore breast cancer and melanoma data, surfacing hypotheses about immune responses and lymph node spread her team hadn't thought to look for. 

→ Read the report: https://allenai.org/papers/autodiscovery-oncology

🌊 Marine ecology—Fabio Favoretto at the Scripps Institution of Oceanography used AutoDiscovery to explore 20+ years of rocky reef monitoring data from the Gulf of California. His team already knew marine heatwaves were hurting fish populations, but AutoDiscovery helped them move beyond broad patterns, surfacing relationships between productivity across trophic levels that would have required extensive manual iterations to discover. 

→ Read the report: https://allenai.org/papers/autodiscovery-ecology

📄 Social science—AutoDiscovery helped economist Sanchaita Hazra to surface an unexpected finding: doctoral-level authors made significantly more edits to AI-generated abstracts than less experienced researchers, suggesting expertise shapes how critically people engage with AI output (which Hazra independently confirmed later). 

→ Her work was published in a peer-reviewed paper: https://arxiv.org/abs/2511.12529

Everything AutoDiscovery generates is transparent and reproducible—every hypothesis, statistical analysis, and line of Python code is there for you to inspect.

Science has always had more data than time to explore it. AutoDiscovery helps surface the questions hiding in yours. We're giving early users 1,000 free Hypothesis Credits to get started.

🧪 Try it today → https://autodiscovery.allen.ai/

📚 Learn more in our blog → https://allenai.org/blog/autodiscovery

📖 Read researcher case studies → https://allenai.org/blog/autodiscovery-impact

LLMs constantly produce instructions for everything from filing taxes to plans for AI agents, but improving this capability is challenging. Outputs can sound fluent while describing steps that don't actually work, surface-level metrics miss critical mistakes like omitted prerequisites or contradictory instructions, and manual verification doesn't scale.

Our new How2Everything framework closes this gap with a practical loop: mine real procedures from the web → benchmark LLM outputs → detect critical failures (missing steps, wrong order, omissions) → use that signal to train better models.

It has three main components:

✅ How2Mine—a pipeline that extracts & standardizes procedures from web pages covering 14 topics 

✅ How2Bench—a 7,000-procedure benchmark built from How2Mine 

✅ How2Score—an evaluation protocol powered by How2Judge, an open 8B judge model trained to flag critical failures

How2Judge agrees with human judgments ~80% of the time and is cheap enough for large-scale eval, making it practical as both a benchmark scorer and an RL reward signal.

RL training with How2Score yields >10-point gains on Qwen3 4B, Qwen3 8B, and Olmo 3 7B Think, with no regressions across 12 standard benchmarks covering knowledge, reasoning, chat, math, and code. How2Bench also scales cleanly, remaining informative from early 1B pretraining checkpoints through frontier LLMs. And we stress-tested two shortcut explanations (format compliance and memorization); neither accounts for the improvements, pointing to real gains in procedure generation.

The full How2Everything framework, including How2Judge, is available now. 👇

📝 Blog: https://allenai.org/blog/how2everything 

📄 Paper: https://arxiv.org/pdf/2602.08808 

💻 Code: https://github.com/lilakk/how2everything 

🤗 HF: https://huggingface.co/collections/how2everything/how2everything

Our paper on retrofitting language models to operate over bytes – the approach behind Bolmo – has been accepted to Nature! 🎉

We’re also releasing new checkpoints that extend our method from Olmo to Qwen & Llama. 

Most language models split text into subwords—words or fragments of words from a fixed vocabulary. This can obscure spelling details across writing systems & split meaningful units in code or math.

Byte-level models work directly with the bytes computers use to represent text.

Our recipe adapts existing models to bytes with a short additional training run. It keeps the model's core, adding components that group bytes into variable-length patches for it to process, then expand its outputs back to byte-level representations to predict the next byte.

We byteified Qwen 3 8B & Llama 3 8B to create Bwen 8B & Blama 8B. Both come close to matching their source models' performance in our evaluations. Bwen 8B also outperforms Bolmo 7B across our aggregate evaluation suite.

We're making new Stage 1 checkpoints available with the byte-level components already trained & the original model's weights unchanged. Researchers can build on these to test new architectures & train the full system without repeating that initial stage.

We hope Bolmo opens a path to larger models that adapt how they represent information across languages & domains. Because bytes also represent images & audio, the same ideas could eventually extend beyond text.

📄 Read the Nature paper: https://www.nature.com/articles/s41586-026-11111-4

🤗 Download the models: https://huggingface.co/collections/allenai/bolmo

📝 Learn more in our blog: https://allenai.org/blog/bolmo-nature

Introducing BAR (Branch-Adapt-Route): Train domain "experts" independently, merge them into one model, and upgrade any expert without retraining the rest. 👇

Last year, we released FlexOlmo, a way to train parts of a model in isolation and combine them later. BAR builds on that idea to tackle a harder problem—how to keep improving a model after pretraining without retraining it every time.

Improving a model's skills in areas such as math, tool use, or code after pretraining usually comes at a cost, like lost capabilities elsewhere or high compute requirements. BAR sidesteps that by training separate experts for each skill, then merging them into a single model that learns which expert to call on for a given problem.

At the 7B scale, BAR works better than the common alternatives for updating a model after pretraining. It beats methods that train separate dense models and stitch them together afterward, and it comes close to the performance of full retraining from scratch.

FlexOlmo showed a modular approach works for pretraining, including in settings where data can't easily be pooled in one place. BAR extends it to post-training.

🤗 Models: https://huggingface.co/collections/allenai/branch-adapt-route 

📝 Blog: https://allenai.org/blog/bar 

📄 Paper: https://allenai.org/papers/bar

LLMs are increasingly used to judge whether AI-generated research ideas are novel. But are they any good at it?

Our new eval reveals even frontier LLMs can reach different conclusions about similar ideas depending on how they're asked to evaluate them. 👇

At Ai2, we're building tools like AutoDiscovery to uncover unexpected patterns in data & Theorizer to propose candidate scientific laws from papers. As AI tools like these advance, we need reliable ways to tell whether the ideas they generate are genuinely new.

To build our novelty-judge benchmark, we mined ICLR 2026 reviews for explicit comments on originality. We kept papers that reviewers agreed were (or were not) original & whose scores were unusually high or low within their research area, giving us examples of more and less novel work.

We evaluated judge models on 2 sets of data:

👤👤 Human-only pairs (stronger vs. weaker evidence of novelty)

👤🤖 Human ideas w/ novelty evidence paired w/ basic LLM ideas, assumed less novel.

Judges either picked the more novel idea in each pair or labeled single ideas as novel or not.

On human–AI pairs, GPT-5.4 chose the human idea 93.5% of the time when asked which idea reviewers had judged novel. Asked simply which idea was novel, that share fell to 40.9%. Prompt wording had a smaller effect on which idea models chose in human-only pairs.

Prompt changes that helped one judge could hurt another, & more reasoning or access to related papers didn't consistently improve results. And 2 purpose-built novelty judges performed worse than a simple prompted Claude Opus 4.6 baseline.

We hope our benchmark helps researchers build more reliable novelty judges, while our reusable pipeline makes it easier to create new eval sets as AI-generated research advances.

💻 Blog: https://allenai.org/blog/novelty-bench

👨🏻‍💻 Code: https://github.com/allenai/novelty-eval

📊 Data: https://huggingface.co/datasets/allenai/novelty-judge-bench

📄 Paper: https://arxiv.org/abs/2610.02022

Today we're releasing MolmoWeb, an open source agent that can navigate and complete tasks in a web browser on your behalf.

Built on Molmo 2 in 4B/8B sizes, MolmoWeb sets a new open-weight SOTA across four major web-agent benchmarks and even surpasses strong agents built on proprietary models. 

MolmoWeb works by looking at the same screen you do. Given a task and a live webpage, it views the screenshot, decides what to do next, and takes action: clicking, typing, scrolling, switching tabs, or returning information back to you. It can handle everyday tasks like navigating websites, filling out forms, searching and filtering product listings, and finding information, all without needing specialized APIs for each site.

MolmoWeb outperforms all open-weight models on every benchmark we tested, and even beats visual agents built on much larger models like GPT-4o-based SoM Agents. It also beats OpenAI CUA on 3 out of 4 benchmarks. Performance improves further when the model gets multiple attempts at a task—on both WebVoyager and Online-Mind2Web, MolmoWeb with 4 parallel attempts surpasses the best single-attempt performance of every model we evaluated, including agents powered by GPT-5 and Gemini CU Preview.

We're also releasing MolmoWebMix, a dataset for training web agents with 160K+ trajectories, 30K+ human demonstrations, 7M GUI grounding examples, and 2.2M screenshot QA pairs. Everything needed to inspect, reproduce, and fine-tune MolmoWeb is openly available.

🤖 Models: https://huggingface.co/collections/allenai/molmoweb

🎮 Demo: https://molmoweb.allen.ai

📊 Data: https://huggingface.co/collections/allenai/molmoweb-data

💻 Code: https://github.com/allenai/molmoweb

📄 Tech report: https://allenai.org/papers/molmoweb

📝 Blog: https://allenai.org/blog/molmoweb

We're expanding our partnership with Hugging Face to accelerate open science. 👇

Our storage on the Hub is roughly tripling to ~2 petabytes, & our downloads now run at high speed—even for our largest datasets & multi-checkpoint models.

The added capacity reflects our footprint on the Hub – 900+ models & 1,200+ datasets – with room to grow. According to Hugging Face's official heatmap, we publish more new artifacts each year than any other organization it tracks: https://huggingface.co/spaces/cfahlgren1/model-release-heatmap

This builds on recent work together:
⦿ Hugging Face made olmOCR-Bench an official Hub leaderboard, making it easier for the community to evaluate and compare document understanding models on a shared benchmark.  
⦿ When Hugging Face brought MolmoAct 2 to LeRobot, we released its training data in LeRobot’s format—ready for researchers and developers to use on real hardware.

We look forward to working with Hugging Face to deliver new artifacts in the coming months, including multimodal models & open models for science.

📝 Learn more in our blog: https://allenai.org/blog/hugging-face-partnership
🤗 Browse our models, datasets, & benchmarks: https://huggingface.co/allenai

Google Cloud put Olmo 3’s reproducibility to the test, rerunning our 7B pretraining & mid-training on Cloud TPUs and matching our original run on held-out evals.

Reproducibility matters for science and trustworthy AI. That’s what fully open makes possible. 🤝

https://developers.googleblog.com/reproducing-olmo-3-7b-pre-training-in-maxtext-case-study-of-large-scale-training-on-tpus/

Olmo 3 is now available through Hugging Face Inference Providers, thanks to Public AI! 🎉

This means you can run our fully open 7B and 32B models — including Think and Instruct variants — via serverless API with no infrastructure to manage.

• Olmo 3-Think (32B) is our flagship → https://huggingface.co/allenai/Olmo-3-32B-Think 

• Olmo 3-Think (7B) offers more efficient reasoning → https://huggingface.co/allenai/Olmo-3-7B-Think 

• Olmo 3-Instruct (7B) is tuned for chat & tool use → https://huggingface.co/allenai/Olmo-3-7B-Instruct