File size: 8,903 Bytes
d8cd3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
802b835
 
 
c7c224e
 
802b835
 
 
 
 
 
d8cd3a3
 
 
 
 
 
 
 
 
 
 
802b835
 
 
d8cd3a3
802b835
 
 
 
 
 
 
 
d8cd3a3
802b835
 
 
 
 
 
 
 
d8cd3a3
 
 
 
 
 
 
 
 
 
 
802b835
 
d8cd3a3
 
 
 
 
802b835
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
d8cd3a3
 
 
 
 
 
 
 
 
 
 
802b835
 
d8cd3a3
 
802b835
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
d8cd3a3
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
---
license: mit
language:
- en
pretty_name: LocalAgentBrowser on SimpleQA
size_categories:
- n<1K
task_categories:
- question-answering
tags:
- simpleqa
- web-agent
- evaluation
- grounding
- citations
- small-models
configs:
- config_name: simpleqa_200
  data_files: simpleqa_200.jsonl
  default: true
- config_name: simpleqa_50
  data_files: simpleqa_50.jsonl
---

# LocalAgentBrowser on SimpleQA

Every answer, citation and grade from [LocalAgentBrowser](https://github.com/SnowFXXX/LocalAgentBrowser) (L.A.B.)
runs on [SimpleQA](https://openai.com/index/introducing-simpleqa), OpenAI's benchmark of short, hard factual
questions. L.A.B. is an open-source web research agent built for small models: it searches DuckDuckGo, reads pages
in a real browser, and code checks every finding against the page it came from before it counts. Its answers are
written only from those findings, each with its source.

## In short

- **85% of the standard 200, and right 94% of the time when it answered** (170 of 181), with Phi-4 (14B).
  19 times it said it couldn't verify an answer rather than guess; 11 answers were wrong.
- **Two graders agree on 194 of the 200:** Claude, with the judgement calls reviewed by the author, and
  OpenAI's own simple-evals grader (GPT-4.1). They count 170 and 171 correct.
- **The same model alone, with no browsing, answered 1 of 50; with L.A.B., 45 of the same 50.**
- **On a CPU with no GPU,** Qwen2.5-7B in L.A.B. answered 35 of 50. For comparison, the Fathom-DeepResearch paper
  ([arXiv 2509.24107](https://arxiv.org/abs/2509.24107), Table 1) reports 50.8% for Qwen2.5-7B with plain search;
  that is a different set of questions and grader, so it's a reference point, not a head-to-head result.

## Results

**`simpleqa_200`** (default): the 200 questions OpenAI's [simple-evals](https://github.com/openai/simple-evals) runs
with `--examples 200`, on L.A.B. 1.66 with Phi-4 through OpenRouter, November 16, 2026. The run took 142 minutes and
2,762 model calls, for $0.58.

| Grader | Correct | Wrong | Not attempted | F-score |
|---|---|---|---|---|
| Claude, judgement calls reviewed by the author | **170 (85%)** | 11 | 19 | **0.892** |
| OpenAI's simple-evals grader (GPT-4.1) | 171 (85.5%) | 15 | 14 | 0.886 |

With 200 questions, the likely range for 85% is about 79% to 89% (Wilson, 95%).

**`simpleqa_50`**: six runs on an earlier random 50, including the models alone with no browsing:

| Run | Correct | Wrong | Not attempted | F-score | OpenAI's grader: correct | Likely range |
|---|---|---|---|---|---|---|
| L.A.B. 1.66, Phi-4 | 45 | 4 | 1 | 0.909 | 46 | 79–96% |
| L.A.B. 1.65.1, Phi-4 (Nov 15) | 39 | 5 | 6 | 0.830 | 39 | 65–87% |
| L.A.B. 1.65.1, Phi-4 (Nov 11) | 38 | 6 | 6 | 0.809 | 38 | 63–86% |
| Phi-4 alone, no browsing | 1 | 34 | 15 | 0.024 | 3 | 0–11% |
| L.A.B. 1.64, Qwen2.5-7B, local on a CPU (no GPU) | 35 | 6 | 9 | 0.769 | 36 | 56–81% |
| Qwen2.5-7B alone, no browsing | 0 | 13 | 37 | 0 | 0 | 0–7% |

## The questions

- **The 200** are exactly the draw simple-evals makes for `--examples 200`: `random.Random(0).sample` over the rows of
  `simple_qa_test_set.csv`, in the order drawn (seed 0, simple-evals' own). Anyone running simple-evals with
  `--examples 200` gets the same questions.
- **The 50** were drawn with `random.Random(20261106).sample` over the same rows, then sorted. One question is in both.
- `simpleqa_index` is each question's 0-based row in `simple_qa_test_set.csv`. The repository's `run.py sample`
  redraws either set and checks the file's SHA-256 first.

## Fields

| Field | What it is |
|---|---|
| `run` | Which run the row belongs to |
| `setting` | L.A.B. with a cloud or local model, or the model alone |
| `model`, `lab_version` | The model, and the L.A.B. version (none for the model alone) |
| `question_number` | The question's number in its sample (1 to 200, or 1 to 50) |
| `simpleqa_index` | The question's row in SimpleQA's `simple_qa_test_set.csv` (0-based) |
| `topic`, `question`, `reference_answer` | From SimpleQA |
| `answer` | The final answer exactly as it was graded, including any notes L.A.B.'s code added (see below) |
| `answer_without_notes` | The same answer with those code notes removed, for reading |
| `cited_discoveries` | The discovery numbers the answer cites |
| `discoveries` | Every finding the agent recorded: its number, the page's URL and the text taken from the page |
| `grade` | CORRECT, INCORRECT or NOT_ATTEMPTED: graded by Claude, judgement calls reviewed by the author |
| `grade_note` | Why, for every wrong answer, judgement call and borderline grade |
| `grade_openai` | The grade from simple-evals' own grader prompt and model (GPT-4.1) |
| `reviewed_by_author` | True for the 45 rows whose grade the author reviewed (48 review items; three rows came up twice) |
| `grade_changed_in_review` | True for the 2 rows the author changed: `simpleqa_200` q2 and q157 |
| `grade_before_review` | Claude's grade before the change, on those 2 rows |

## How it was graded

- **SimpleQA's three grades.** CORRECT: contains the reference answer and contradicts nothing. INCORRECT: a different
  answer, a contradiction, or a hedge between candidates ("22 or 23"). NOT_ATTEMPTED: says it couldn't find out, with
  no wrong answer.
- **Partial answers** that give part of the reference and nothing wrong ("May 2019" for May 28, 2019; "May 2000" for
  2 May 2000) are NOT_ATTEMPTED in `grade`, following SimpleQA's definition. OpenAI's grader counts those two as
  INCORRECT; both grades are kept.
- **Order and review.** Claude graded each answer against the reference, one at a time, before seeing the automatic
  grades, with a note for every wrong answer, judgement call and borderline grade. The author reviewed every one of
  them (18 in the 50-question runs, 30 in the 200), agreed with 46 and changed 2. OpenAI's grader ran afterwards on
  the same `answer` text.
- **Why a second grader:** L.A.B.'s principle is not taking a model's word for it, so the grades shouldn't rest on one
  model either. simple-evals' grader is the field's shared standard, and it agrees on 194 of the 200.

## Notes from L.A.B.'s code inside answers

Some answers end with notes added by L.A.B.'s checks, not by the model:
- **"Left out, because no discovery gives these numbers (the pages read may still have them): …"**: a number or name
  the model wrote was removed because no recorded finding contains it.
- **"Not found in the pages read: …"**: parts of the question no finding answered. On some single-answer questions
  this list is garbled ("ten more (only none of the ten were found)") because the check read a number in the question
  ("track 10") as a count. A known bug, being fixed; it changed no grade.
- **"> ⚠️ Numbers not found in the recorded discoveries"**: the same check, as a warning.

The answers are kept exactly as graded, notes included; `answer_without_notes` has them removed. Whether a number
inside a "Left out" note counts as the answer is the author's judgement call row by row: in q2 of the 200 it was
counted ("33 years" for 32, INCORRECT), in q88 it wasn't ("2020" for April 2019, NOT_ATTEMPTED). Each row's
`grade_note` says which.

## How it was run

- Each question was given to the agent as an ordinary objective, with 60 minutes and nothing carried over from the
  question before.
- Sites that republish SimpleQA with its answers were blocked, so every answer had to be found on the open web.
- Search: DuckDuckGo's free HTML results, not a paid search API.
- The questions, scripts, reports and grading notes are in the repository's
  [benchmarks/simpleqa](https://github.com/SnowFXXX/LocalAgentBrowser/tree/main/benchmarks/simpleqa) folder.

## Caveats

- Every score here is self-reported by the project that built the agent.
- "Small models" here means 7B on a CPU and Phi-4 (14B) in the cloud: small next to frontier models, but the 200 ran
  on a cloud model, not on a CPU. A 200-question run on the local 7B is planned.
- SimpleQA has been public since 2024, and some of its reference answers are known to be wrong.

## Citation

```bibtex
@misc{snowfx2026labsimpleqa,
  author       = {SnowFX},
  title        = {LocalAgentBrowser on SimpleQA: answers, citations and grades},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/SnowFX/localagentbrowser-simpleqa}}
}

@misc{wei2024simpleqa,
  author        = {Wei, Jason and others},
  title         = {Measuring short-form factuality in large language models},
  year          = {2024},
  eprint        = {2411.04368},
  archivePrefix = {arXiv}
}
```

## License

MIT, like the LocalAgentBrowser repository. SimpleQA's questions and reference answers are © OpenAI under the MIT
license. The `discoveries` texts are short excerpts from the pages listed beside them, and remain under those pages'
own terms.