---
title: "What Is AREX-2? BAAI's 27B Model That Runs Its Own Retry Loop"
url: "https://goremy.ai/blog/articles/arex-2-27b-model-runs-its-own-loop"
author: Luis Chavez-Mattos
editor: Luis Chavez-Mattos
editor_title: Director, Product
published: "2026-11-10T06:40:14.111Z"
updated: "2026-11-10T17:00:50.883Z"
topic: AI Models & Industry
description: "AREX-2 is BAAI's 27B open-weights model trained to try, check and revise for hours. See its MLE-Bench Light scores and what it means for harnesses."
---

# What Is AREX-2? BAAI's 27B Model That Runs Its Own Retry Loop

> AREX-2 is BAAI's 27B open-weights model trained to try, check and revise for hours. See its MLE-Bench Light scores and what it means for harnesses.

Edited by Luis Chavez-Mattos, Director, Product · Published 2026-11-10

## What is AREX-2?

AREX-2 is an open-weights 27B model from the Beijing Academy of Artificial Intelligence (BAAI) and two partner universities, released under Apache 2. It is a fine-tune of Qwen3.8-27B trained to run its own try, check, revise loop over many rounds. You give it a budget, such as five hours or a set number of rounds, and it paces itself. The usual retry logic that lives in your agent harness is moved into the model.

## TL;DR

- AREX-2 is a **27B Apache 2 fine-tune of Qwen3.8-27B** built for long-running agent work, with a paper on arXiv.
- It scores **81.8 on MLE-Bench Light**, ahead of the 72.7 posted by GPT 5.6 Soul, the comparison model named in the coverage.
- On FrontierCS it reaches 70.7, the best open-weights result, about six points behind GPT 5.6 Soul.
- Training was **supervised fine-tuning on full trajectories with failures left in context**, not reinforcement learning.
- Skills in the prompt did most of the work: the training added roughly **14 points on top of a skills-equipped base model**.
- The score gains are **test-time self-improvement only**. The weights do not change between tasks.
- Harnesses are not going away, but their job shifts toward feedback, skills and budgets, and away from loop control.

## What problem is AREX-2 trying to solve?

If you have built an agent in the last year, you have probably written the loop yourself. The model makes one attempt. Your code runs it, checks the result, decides whether to retry, keeps the best version so far and decides when to stop. All of that sits in the harness. The model only ever sees one attempt at a time.

AREX-2 asks what happens if the model owns that logic. Hand it a budget and let it decide how to spend the hours. Early rounds are for measuring. Later rounds are for acting on what it measured.

## How does AREX-2 work?

The design rests on two capabilities that multiply each other.

1. **Reflection.** Given the current state and the feedback it just received, can the model produce a better attempt? This also determines how much each round is worth.
2. **Long-horizon execution.** Can it keep going for hours, remember what it already tried and recover when a change makes things worse? This determines how many rounds stay useful before the model stalls.

If reflection is weak, extra rounds just burn tokens. If the horizon is short, even sharp reflection plateaus. The model is also told how many rounds it has and uses that to pace itself.

This split is a handy diagnostic for your own agents, whatever model they use. If your agent keeps making bad changes, you likely have a weak feedback signal. If it keeps redoing work it already tried, you likely have a state and memory problem. They are different problems with different fixes.

## How was AREX-2 trained?

Most agent training data is built like this: pose a task, let the model try, run a verifier, keep the passes. That shows what a correct answer looks like. It says little about how an answer gets better. The failed attempts, the feedback and the fixes are discarded, and those messy runs that start badly and finish well are often the most useful ones.

The AREX-2 team built its own data in two domains: machine learning engineering and algorithmic programming. Both give unambiguous feedback (a validation score goes up or it does not, tests pass or fail) and both leave room to improve for a long time, from a baseline to a tuned ensemble or from brute force to near-optimal code.

The pipeline has three steps:

1. A teacher model turns GitHub repos into environments, each with a task and a scoring function.
2. A teacher agent works on an environment for hours, making hundreds of tool calls: reading code, searching papers, running small experiments.
3. The full trajectories are kept, selected by how they finished.

The notable choice is that failures stay in. Failed rounds remain in context, but the loss only covers steps that moved things forward. The model sees messy runs and learns how to respond to them.

The launch material talked about reinforcing these tasks, which sounds like RL. It is not. This is supervised fine-tuning on the trajectories, mixed with deep research data from the first AREX model. The sources do not say which teacher model generated the trajectories, and the datasets and training code do not appear to be released.

If you fine-tune on your own agent traces, the recipe transfers: select trajectories by outcome rather than step by step, and mask the loss so you train on recovery and progress.

## How well does AREX-2 perform?

| Benchmark | AREX-2 | GPT 5.6 Soul |
|---|---|---|
| MLE-Bench Light | 81.8 | 72.7 |
| FrontierCS (open-ended algorithmic problems) | 70.7 | about 6 points higher |

AREX-2 is the best open-weights result on FrontierCS. It also beats the earlier AREX models on all four research benchmarks in the paper, including the 122B-parameter version. That is a 27B model, and the comparison model is plausibly much larger, though its size is not stated.

The more telling chart is score against time. Over a five-hour budget, AREX-2 does not start in front. It sits at 54 after one hour, 66 after two and 70.7 after five (the last figure matches its FrontierCS score). DeepSeek 4 Pro, by contrast, flattens at about 45 after two hours and barely moves afterward. The pitch is a model that is still improving hours into a run.

## Is the improvement from the model or from skills?

Both, but skills carry more of it. MLE-Bench Light was run with skills in context: general ML practice plus task-specific skills built by searching around each problem. The paper includes an ablation:

| Setup | Score |
|---|---|
| Qwen3.8-27B, no skills | 28.8 |
| Plus general skills | 41.2 |
| Plus task-specific skills and more rounds (still untrained base) | about 68.2 |
| AREX-2 with the same skills and rounds | 81.8 |

Skills and more rounds lift the base model from 28.8 to about 68.2. Training adds around 14 more points. The fine-tuning is real, but it is the smaller lever. That fits what many builders have already seen: good operational knowledge in context moves results quickly.

## Is this recursive self-improvement?

BAAI frames it that way, but the claim needs a careful reading. What AREX-2 shows is self-improvement at test time. Inside one task, the model gets better over many rounds. The weights stay fixed. It is like giving an intern a week to try 20 approaches, then wiping their memory before the next assignment so they must try all 20 again.

Closer to true recursive self-improvement would be feeding a model's successful trajectories back in as training data, so the next generation needs fewer attempts. The paper names that as the path forward.

## Does a self-looping model change how agents should be built?

Probably, though it will not make harnesses obsolete. If more models are trained this way, the harness needs to manage the loop less: when to retry, what to keep, what to stop, what to swap out. Its work moves to three things:

- **A real feedback signal.** Actual scores, logs and errors, not vague pass/fail text.
- **Operational knowledge.** Skills, as the ablation shows.
- **A budget.** Deciding how long the model should run.

Expect friction. If your framework has its own reflect and retry nodes while the model paces itself over one long session, you have two loops competing. A harness that resets context every few steps could make a model like this worse, because it breaks the continuity the model was trained to rely on. Long-horizon runs are also becoming an infrastructure concern, and the source notes that Google Cloud is introducing seven-day model runs.

A practical test is to run the same loop, prompt and budget against the base Qwen3.8-27B and AREX-2, and see whether only the trained model keeps improving without scaffolding. Vary the budget (three rounds versus twelve) and check whether round-one planning changes. The creator who covered the model built a small harness for exactly this, but that is a simplified setup, not BAAI's own.

## Frequently Asked Questions

### Is AREX-2 open source?

The model weights are open under the Apache 2 license. The sources indicate the training datasets and training code have not been released, and the teacher model used to generate trajectories is not identified.

### Is AREX-2 trained with reinforcement learning?

No. Despite launch wording about reinforcing tasks, it is supervised fine-tuning on selected trajectories, mixed with deep research data from the first AREX model. The loss is applied only to steps that moved the work forward.

### Does AREX-2 learn between tasks?

No. The improvement happens inside a single task over many rounds. Weights do not change, so the model starts fresh on the next problem.

### Should I remove retry logic from my harness?

Not blindly. A model trained to pace itself over one long session may conflict with a harness that resets context or forces its own retry nodes. Focus the harness on feedback quality, skills and budget, and test whether outer loops help or hurt.