---
license: openrail
base_model: Qwen/Qwen3-VL-2B-Instruct
datasets:
  - stanfordnlp/nnetnav-wa
  - stanfordnlp/nnetnav-live
  - osunlp/Multimodal-Mind2Web
language:
  - en
library_name: peft
pipeline_tag: image-text-to-text
tags:
  - computer-use
  - browser-agent
  - web-agent
  - accessibility-tree
  - vision-language
  - reasoning
  - lora
---

# Reflex Reason 2B

**Reflex Reason** is the thinking model behind **Reflex**, a local browser agent by Atlas AI. It looks at a
screenshot of the page together with its accessibility tree, reasons step by step about what to do next, and then
gives exactly one action.

In Reflex, the fast decision model [Reflex Instinct 0.6B](https://huggingface.co/Atlas-AI-research/reflex-instinct-0.6b)
handles every step it is confident about, in about 0.2 s. When Instinct's calibrated confidence falls below a threshold,
the step goes to Reason, which takes a few seconds and sees the page.

- **Sees the page:** it reads a screenshot and the accessibility tree together
- **Thinks first:** it writes its reasoning inside `<think>`, then gives one action in triple backticks
- **Runs locally:** a LoRA adapter on Qwen3-VL-2B-Instruct that fits on a consumer GPU
- **Better together:** routing Instinct and Reason scored **52.4%** step accuracy, against 26.8% for Instinct alone

**Code:** [github.com/leemadov/reflex](https://github.com/leemadov/reflex): the Reflex browser agent that runs this model (Chrome extension and desktop app), plus the training, evaluation and JevBench scripts.

## Results

Measured on held-out steps after 1,244 training steps (6.9 hours on one RTX 5070):

| Set | Steps | Operation | Element | Full step | Latency p50 |
|---|---|---|---|---|---|
| Multimodal-Mind2Web (screenshot + tree) | 100 | 98% | 77% | **76%** | 3.6 s |
| NNetNav live web (tree only) | 81 | 55.6% | 42.0% | **34.6%** | 6.9 s |
| NNetNav WebArena sites (tree only) | 69 | 43.5% | 33.3% | **29.0%** | 5.5 s |

**Routing (the way Reflex uses it).** Instinct decides first, and any step where its confidence is below 0.2 goes to
Reason. On the same 250 held-out steps, this scored **52.4%** step accuracy against **26.8%** for Instinct alone,
calling Reason on 59% of steps. A threshold of 0.2 tied for the best accuracy, and higher thresholds only add Reason calls.

**How to read this:**
- **Mind2Web is the easiest of the three.** The test set is 5% of Multimodal-Mind2Web's tasks, held out from its
  train split, so its websites can overlap with training. Pages were also cut to a window of the tree that contains
  the target. That is not Mind2Web's official cross-website benchmark.
- **The NNetNav labels are noisy.** They come from an LLM explorer, so a step often has several reasonable next
  actions and the logged one is only one of them.

## Usage

The model loads with standard `transformers` and `peft`. This example runs as written (tested on CPU):

```python
import torch
from peft import PeftModel
from transformers import AutoProcessor, Qwen3VLForConditionalGeneration

BASE, ADAPTER = "Qwen/Qwen3-VL-2B-Instruct", "Atlas-AI-research/reflex-reason-2b"
processor = AutoProcessor.from_pretrained(BASE)
model = Qwen3VLForConditionalGeneration.from_pretrained(BASE, dtype=torch.bfloat16, device_map="auto")
model = PeftModel.from_pretrained(model, ADAPTER).merge_and_unload().eval()

SYSTEM = ("You are a web agent. Given the task, the URL, your previous actions, the page's accessibility tree and "
          "possibly a screenshot, think step by step about what to do next, then give exactly one action in triple "
          "backticks. Actions: click [id], type [id] [text], select [id] [option], hover [id], press [key_comb], "
          "scroll [down|up], goto [url], go_back, go_forward, new_tab, tab_focus [index], close_tab, "
          "stop [answer] (stop [N/A] if the task is impossible).")
state = ("task: Find reviews for a product in the Electronics category.\n"
         "url: http://shop.local/\n"
         "history: none\n"
         "page:\nRootWebArea 'One Stop Market'\n\t[227] link 'My Account'\n\t[815] menuitem 'Electronics'\n\t[272] combobox 'Search'")
prompt = (f"<|im_start|>system\n{SYSTEM}<|im_end|>\n<|im_start|>user\n"
          f"{state}<|im_end|>\n<|im_start|>assistant\n<think>\n")
inputs = processor(text=[prompt], return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=384, do_sample=False)
print(processor.decode(out[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True))
```

Output:

~~~text
Let's think step-by-step. The current webpage is the main page of the One Stop Market, and the objective is to find
reviews for a product in the Electronics category. The current webpage has a menuitem 'Electronics' with id [815].
This menuitem seems to be related to the Electronics category. I will click on this menuitem to navigate to the
Electronics category page.
</think>
```click [815]```
~~~

**With a screenshot.** Resize the browser window's screenshot to fit inside **1024×640**, which is what the model
was trained on (640 image tokens), padding with black instead of stretching. Then put the image marker at the start
of the user turn and pass the image to the processor:

```python
from PIL import Image
image = Image.open("page.png").convert("RGB")   # already fitted to 1024x640
prompt = (f"<|im_start|>system\n{SYSTEM}<|im_end|>\n<|im_start|>user\n"
          f"<|vision_start|><|image_pad|><|vision_end|>\n{state}<|im_end|>\n<|im_start|>assistant\n<think>\n")
inputs = processor(text=[prompt], images=[image], return_tensors="pt").to(model.device)
```

**Input format:**
- The state is `task:`, `url:`, `history:` (one previous action per line as `- ...`, or `none`) and `page:`.
- The page should be a WebArena/BrowserGym accessibility tree: one element per line as `[id] role 'name' properties`,
  tab-indented by depth.
- Prompts were up to 7,168 tokens in training. Trim long pages by whole lines.

**Parsing the answer:** take the last triple-backtick block, for example `click [815]` or `type [272] [usb hub]`.

## As a decision model (Jev wire format)

`serve.py` in this repo serves Reason as a Jev-style decision model on `/v1/systemone` (TypeSafe-compatible):

```bash
pip install torch transformers peft fastapi uvicorn
python serve.py --port 8766
```

For each question it thinks first (greedy, up to 384 tokens), then letters the options A, B, C... and reads its score
for each letter after `</think>` and the opening triple backticks, in one forward pass. A softmax at temperature 3.176 turns those into a probability
for every option. That temperature was fitted (lowest log-loss) on JevBench's 231 public items; `--temperature 1`
gives the raw model.

On those 231 public items, through JevBench's own `typesafe` adapter, it scored easy 100%, standard 87.5% and hard
47.7%, at a median 5 s per decision on an RTX 5070. To check the temperature, it was fitted on one half of the items
and tested on the other half, and the other way round. These are our own measurements, not JevBench's.

## Training

- **Base model:** `Qwen/Qwen3-VL-2B-Instruct` with a LoRA adapter (rank 32, alpha 64) on the language model's
  attention and MLP projections. The vision tower is frozen.
- **Text steps:** [NNetNav](https://arxiv.org/abs/2410.02907)
  ([nnetnav-wa](https://huggingface.co/datasets/stanfordnlp/nnetnav-wa),
  [nnetnav-live](https://huggingface.co/datasets/stanfordnlp/nnetnav-live)), using each step's step-by-step
  reasoning as the target thought.
- **Screenshot steps:** [Multimodal-Mind2Web](https://huggingface.co/datasets/osunlp/Multimodal-Mind2Web), 5,660
  steps. Screenshots were cropped to a 1280×800 window holding the target and resized to 1024×640. They made up 30% of
  training steps.
- **Target format:** the reasoning, then `</think>`, then the action in triple backticks, after a prompt that
  ends in `<think>`. The loss was on the answer only.
- **Run:** 1,244 optimizer steps (8 sequences each, learning rate 1e-4) in 6.9 hours on one RTX 5070.

## Limitations

- **Short template on screenshot steps.** On Mind2Web-style screenshot pages its reasoning often copies Mind2Web's
  short template ("the next step on this page is to click [id]") instead of really reasoning.
- **Slow by design.** It takes 3–7 s per step, so it is meant for the uncertain steps, not every step.
- **Learned an explorer's habits.** The training labels come from an LLM explorer and from Mind2Web annotators, so
  it learned their habits along with the task.
- **English only.**
- **Keep a person in the loop.** Never let an agent type passwords or payment details on its own, and keep a person
  in the loop for anything irreversible.

## License

**OpenRAIL.** Reason was trained partly on Multimodal-Mind2Web, which is released under OpenRAIL, so its use
restrictions carry over to this model. The base model (Qwen3-VL-2B-Instruct) and NNetNav are Apache 2.0.

Built by **Atlas AI**.