Datasets:

MicroAGI-Labs
/

MicroAnnotationBench

---
license: cc-by-nc-4.0
license_name: cc-by-nc-4.0-data-apache-2.0-code
license_link: LICENSE
pretty_name: MicroAnnotationBench
language:
  - en
task_categories:
  - video-classification
tags:
  - video
  - egocentric
  - temporal-action-segmentation
  - action-labelling
  - robotics
  - benchmark
size_categories:
  - n<1K
annotations_creators:
  - expert-generated
language_creators:
  - expert-generated
multilinguality:
  - monolingual
source_datasets:
  - original
configs:
  - config_name: session_disjoint_30
    data_files:
      - split: test
        path: data/session_disjoint_30/labels.jsonl
  - config_name: operator_disjoint_59
    data_files:
      - split: test
        path: data/operator_disjoint_59/labels.jsonl
  - config_name: nanoannot-1_predictions
    data_files:
      - split: session_disjoint_30
        path: predictions/session_disjoint_30/nanoannot-1.jsonl
      - split: operator_disjoint_59
        path: predictions/operator_disjoint_59/nanoannot-1.jsonl
gated: manual
extra_gated_heading: "Request access to MicroAnnotationBench"
extra_gated_description: "The videos show real people doing manual work. Access is granted to researchers and teams evaluating annotation models. Fill in the form; requests are reviewed by hand."
extra_gated_prompt: "By requesting access you agree to: (1) use the data only for research and for evaluating models on this benchmark, under CC BY-NC 4.0 (no commercial use); (2) not redistribute the videos; (3) not attempt to identify the people in the clips; (4) not train on the benchmark clips or their labels. You will receive the released half of the benchmark: 45 raw clips, human segment timelines, nanoannot-1's published timelines, the judge prompts and the scoring code."
extra_gated_fields:
  Name: text
  Email: text
  Organisation: text
  What will you evaluate with it?: text
  I agree to the terms above: checkbox
extra_gated_button_content: "Request access"
---
# MicroAnnotationBench

**Scoring timed, labelled action timelines of egocentric work video against human annotation.**

[Blog post](https://www.microagi.ai/benchmarks/microannotationbench) · [Leaderboard](#leaderboard) · [Score a timeline](#quick-start-score-a-timeline) · [Run your own model](#running-your-own-model) · [Cite](#licence-and-citation)
microagi · October 2026 · data CC BY-NC 4.0, code Apache-2.0

Robot policies learn from egocentric video once it has been cut into short, labelled actions: what the
hands do, to which object, with which hand, and exactly when. MicroAnnotationBench measures how well a
model produces that timeline from raw video. It scores the **whole timeline**, boundaries and labels,
against human annotation, on clips that average just over a minute of continuous manual work.

| | |
|---|---|
| Clips | **45 released** of 89 (30 of the 59 operator-disjoint, 15 of the 30 session-disjoint), 46.8 minutes of video; the other 50% of each set is held back |
| Mean clip | 62.4 s, 13.7 human-labelled actions (released clips) |
| Video | raw camera clips, 1920×1080, 30 fps, H.264 MP4 (5.0 GB) |
| Reference | human segment timelines: start, end, imperative label (action, object, hand), idle flag |
| Metrics | PA-F1 and strict PA-F1 (labels, judge-scored), Boundary F1 (strict timing), Temporal F1 (coarse timing), Segmentation F1@0.75 and Joint semantic F1@0.75 (WGO-Bench definition) |
| Headline score | 50% PA-F1 + 25% Boundary F1 + 25% Temporal F1, over the clips of both sets |
| Published results | 25 configurations of 11 models (nanoannot-1, nine API or open-weight models at one to four reasoning efforts, NVIDIA's Flora pipeline), 5 generation seeds each, on the full sets and on the released half; nanoannot-1's timelines included |

## Leaderboard

All 89 clips of the two sets, each model at its best reasoning setting (best headline score). Every model sees the same
video at 720 px and 6 frames per second. Mean over 5 generation seeds (1, 11, 21, 31, 41), ± the standard deviation between
seeds; Flora is one greedy run. All 89 = both sets weighted by clip count (59 / 30).
**This repository releases 50% of each set**; the same runs on the released clips are in
[Released clips only](#released-clips-only-compare-your-own-runs-with-these): compare your own scores with those.

| Model (best setting) | Score | PA-F1 | Strict PA-F1 | Boundary F1 | Temporal F1 | Seg F1@0.75 | Joint F1@0.75 | Segments / clip (human 13.8) |
|---|---:|---:|---:|---:|---:|---:|---:|---:|
| **nanoannot-1** (microagi) | **54.0** ± 0.3 | **55.7** | **32.9** | **32.9** | **71.5** | 34.3 | **24.9** | 13.6 |
| Gemini 4 Argon (medium) | 50.4 ± 0.8 | 51.2 | 27.6 | 29.8 | 69.3 | **34.4** | 23.4 | 13.8 |
| Kimi K3.1 Pro (low) | 45.7 ± 0.9 | 48.2 | 27.0 | 22.0 | 64.3 | 26.4 | 16.6 | 13.2 |
| Qwen3.8-Max (low) | 44.6 ± 0.7 | 46.8 | 27.6 | 20.6 | 64.2 | 25.5 | 16.2 | 12.3 |
| Kimi K3 (high) | 42.6 ± 0.9 | 43.0 | 22.4 | 21.2 | 63.2 | 25.7 | 15.5 | 11.5 |
| GLM-5.3-Flash (high) | 42.0 ± 0.8 | 41.9 | 21.7 | 22.3 | 62.1 | 25.7 | 14.2 | 11.2 |
| GPT-6.1 Sol (low) | 41.2 ± 0.5 | 45.5 | 26.0 | 20.6 | 53.4 | 21.6 | 15.6 | 21.0 |
| Qwen3.8-27B (medium) | 40.4 ± 0.6 | 41.4 | 22.5 | 16.9 | 62.0 | 21.1 | 10.7 | 12.5 |
| GPT-6 Astra (medium) | 39.7 ± 0.3 | 44.5 | 26.2 | 20.3 | 49.2 | 19.8 | 15.1 | 22.8 |
| Flora (NVIDIA, own harness) | 39.3 | 42.0 | 22.6 | 19.9 | 53.2 | 19.5 | 12.2 | 25.1 |
| Mistral Large 4 (high) | 35.4 ± 1.3 | 32.3 | 14.1 | 18.6 | 58.2 | 20.6 | 8.7 | 12.3 |

PA-F1, strict PA-F1, precision and recall: mean of 3 judge seeds (DeepSeek V4 Flash). Seg F1 and Joint F1: matches at temporal
IoU ≥ 0.75, counted over all clips of a set; the labels of Joint F1 are judged by Gemini 3.5 Flash. Strict PA-F1, Seg F1 and Joint F1
are not part of the score. Machine-readable: `results/published_results.json`.

**Pairwise tournament** (the best setting of each model, generation seed 1; Bradley-Terry log strength, win rate in brackets):

| Model (best setting) | Timing, operator-disjoint | Labels, operator-disjoint | Timing, session-disjoint | Labels, session-disjoint |
|---|---:|---:|---:|---:|
| **nanoannot-1** (microagi) | +0.62 (66%) | +1.28 (78%) | +0.62 (66%) | +0.94 (71%) |
| Gemini 4 Argon (medium) | +0.70 (68%) | +0.62 (64%) | +0.17 (55%) | +0.76 (68%) |
| GPT-6.1 Sol (low) | +0.18 (55%) | +0.86 (70%) | +0.48 (63%) | +0.72 (68%) |
| GPT-6 Astra (medium) | +0.12 (53%) | +0.89 (70%) | +0.36 (59%) | +0.80 (69%) |
| Kimi K3.1 Pro (low) | +0.11 (53%) | +0.25 (56%) | -0.20 (44%) | +0.51 (62%) |
| Qwen3.8-Max (low) | +0.09 (52%) | +0.05 (51%) | -0.32 (41%) | +0.11 (52%) |
| Flora (NVIDIA, own harness) | -0.28 (43%) | -0.07 (48%) | +0.18 (55%) | -0.20 (44%) |
| Kimi K3 (high) | -0.24 (44%) | -0.34 (41%) | -0.61 (34%) | -0.38 (40%) |
| GLM-5.3-Flash (high) | -0.08 (48%) | -0.93 (29%) | -0.19 (45%) | -0.65 (34%) |
| Qwen3.8-27B (medium) | -0.62 (34%) | -0.77 (32%) | -0.17 (45%) | -0.94 (28%) |
| Mistral Large 4 (high) | -0.60 (35%) | -1.84 (13%) | -0.32 (41%) | -1.66 (15%) |

### Every configuration, per set

### Operator-disjoint set (59 clips, 30 released), all 25 configurations

| Configuration | Score | PA-F1 | Strict PA-F1 | Precision | Recall | Boundary F1 | Temporal F1 | Seg F1 | Joint F1 | Segments / clip (human 15.1) |
|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
| **nanoannot-1** (microagi) | **52.7** | **53.0** | **29.3** | **53.2** | 55.6 | **34.0** | **70.8** | **33.2** | **22.7** | 15.6 |
| Gemini 4 Argon (low) | 48.3 | 47.2 | 24.0 | 47.7 | 49.5 | 31.0 | 67.6 | **33.2** | 20.4 | 15.7 |
| Gemini 4 Argon (medium) | 48.0 | 46.5 | 22.5 | 46.5 | 49.2 | 31.4 | 67.7 | 33.1 | 20.6 | 15.7 |
| Gemini 4 Argon (MAX) | 47.4 | 46.0 | 22.1 | 45.8 | 49.0 | 29.8 | 67.7 | 32.5 | 19.8 | 15.9 |
| Gemini 4 Argon (high) | 44.4 | 44.4 | 20.8 | 40.3 | 52.9 | 26.5 | 62.4 | 28.0 | 17.1 | 19.2 |
| Kimi K3.1 Pro (high) | 44.3 | 44.8 | 23.5 | 44.1 | 48.4 | 24.1 | 63.5 | 26.9 | 15.9 | 15.2 |
| Kimi K3.1 Pro (low) | 44.1 | 44.9 | 23.2 | 44.5 | 48.4 | 23.3 | 63.4 | 25.5 | 14.9 | 15.0 |
| Kimi K3.1 Pro (medium) | 43.7 | 44.2 | 22.8 | 43.3 | 48.1 | 23.5 | 62.8 | 26.0 | 15.2 | 15.3 |
| Qwen3.8-Max (low) | 43.6 | 43.6 | 23.1 | 44.4 | 45.2 | 22.4 | 64.9 | 26.4 | 16.0 | 14.0 |
| Qwen3.8-Max (medium) | 41.8 | 42.0 | 19.5 | 39.9 | 47.5 | 21.7 | 61.6 | 23.3 | 13.8 | 16.9 |
| Qwen3.8-Max (high) | 41.5 | 41.5 | 19.6 | 39.1 | 47.4 | 20.5 | 62.4 | 22.1 | 13.1 | 17.0 |
| Kimi K3 (high) | 41.1 | 39.9 | 18.1 | 41.3 | 40.8 | 21.9 | 62.8 | 25.2 | 14.5 | 13.1 |
| GLM-5.3-Flash (high) | 40.9 | 38.5 | 16.6 | 40.8 | 38.6 | 24.6 | 62.0 | 26.4 | 13.9 | 12.9 |
| Kimi K3 (medium) | 40.9 | 40.8 | 20.0 | 44.5 | 39.5 | 20.2 | 61.9 | 24.8 | 14.5 | 11.7 |
| Kimi K3 (low) | 40.8 | 40.7 | 19.5 | 44.3 | 39.6 | 20.9 | 61.1 | 24.2 | 13.7 | 11.7 |
| GPT-6.1 Sol (low) | 38.7 | 41.9 | 21.5 | 35.1 | 56.3 | 20.2 | 50.9 | 19.2 | 13.0 | 24.1 |
| Qwen3.8-27B (medium) | 38.5 | 37.5 | 17.7 | 37.9 | 39.5 | 17.2 | 61.7 | 20.3 | 10.1 | 14.0 |
| Qwen3.8-27B (low) | 38.4 | 36.6 | 16.7 | 36.6 | 39.2 | 18.6 | 61.6 | 20.2 | 9.9 | 14.3 |
| GPT-6.1 Sol (medium) | 37.7 | 41.3 | 20.4 | 34.3 | 56.5 | 19.3 | 49.1 | 17.1 | 11.7 | 25.2 |
| Flora (NVIDIA, own harness) | 36.6 | 38.7 | 18.6 | 33.2 | 51.1 | 19.0 | 50.0 | 16.0 | 10.2 | 29.8 |
| GPT-6 Astra (medium) | 36.6 | 40.8 | 22.0 | 33.1 | **57.7** | 19.2 | 45.7 | 17.2 | 12.2 | 26.4 |
| GLM-5.3-Flash (low) | 34.3 | 33.8 | 14.1 | 39.9 | 31.3 | 16.8 | 52.7 | 20.3 | 10.7 | 10.8 |
| Mistral Large 4 (high) | 33.6 | 29.4 | 10.2 | 30.1 | 30.6 | 17.7 | 57.9 | 19.6 | 7.6 | 13.8 |
| Mistral Large 4 (low) | 33.3 | 28.5 | 10.8 | 28.8 | 30.2 | 18.2 | 58.1 | 20.2 | 6.5 | 14.0 |
| Mistral Large 4 (medium) | 33.2 | 28.9 | 10.7 | 29.5 | 30.4 | 17.4 | 57.4 | 19.5 | 7.3 | 13.7 |

### Session-disjoint set (30 clips, 15 released), all 25 configurations

| Configuration | Score | PA-F1 | Strict PA-F1 | Precision | Recall | Boundary F1 | Temporal F1 | Seg F1 | Joint F1 | Segments / clip (human 11.1) |
|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
| **nanoannot-1** (microagi) | **56.4** | **61.1** | **40.0** | **63.4** | 61.0 | **30.6** | **72.9** | 36.4 | 29.1 | 9.9 |
| Gemini 4 Argon (medium) | 55.0 | 60.4 | 37.5 | 62.7 | 60.2 | 26.9 | 72.4 | 37.0 | 29.0 | 10.1 |
| Gemini 4 Argon (MAX) | 55.0 | 59.5 | 37.1 | 62.3 | 58.9 | 28.3 | 72.5 | **38.4** | **30.6** | 10.1 |
| Gemini 4 Argon (low) | 53.7 | 58.3 | 36.4 | 60.1 | 59.1 | 27.9 | 70.5 | 36.5 | 27.5 | 10.2 |
| Gemini 4 Argon (high) | 50.5 | 55.9 | 32.1 | 51.7 | 64.8 | 24.7 | 65.5 | 32.7 | 26.6 | 12.7 |
| Kimi K3.1 Pro (low) | 48.7 | 54.5 | 34.4 | 55.3 | 57.4 | 19.6 | 66.2 | 28.0 | 19.8 | 9.8 |
| Kimi K3.1 Pro (high) | 48.3 | 54.0 | 34.7 | 54.4 | 57.3 | 19.0 | 66.2 | 26.5 | 17.6 | 9.9 |
| Kimi K3.1 Pro (medium) | 48.1 | 53.0 | 33.7 | 53.3 | 56.1 | 20.6 | 65.9 | 27.4 | 17.5 | 9.9 |
| Qwen3.8-Max (high) | 46.9 | 50.9 | 30.0 | 49.9 | 55.2 | 19.9 | 65.9 | 25.5 | 17.7 | 10.6 |
| Qwen3.8-Max (low) | 46.6 | 53.3 | 36.5 | 54.7 | 54.5 | 17.1 | 62.8 | 23.8 | 16.5 | 9.0 |
| GPT-6.1 Sol (medium) | 46.3 | 52.6 | 34.5 | 45.1 | 67.9 | 21.7 | 58.3 | 24.5 | 20.7 | 15.0 |
| GPT-6.1 Sol (low) | 46.2 | 52.6 | 34.8 | 46.3 | 66.0 | 21.5 | 58.2 | 26.2 | 20.8 | 14.7 |
| Qwen3.8-Max (medium) | 46.1 | 50.7 | 29.5 | 49.4 | 55.5 | 19.7 | 63.5 | 25.4 | 16.6 | 10.6 |
| GPT-6 Astra (medium) | 45.6 | 51.9 | 34.5 | 43.9 | **68.6** | 22.5 | 56.3 | 25.1 | 20.9 | 15.6 |
| Kimi K3 (high) | 45.6 | 49.2 | 30.9 | 52.6 | 48.7 | 19.9 | 64.1 | 26.7 | 17.6 | 8.3 |
| Kimi K3 (medium) | 45.6 | 49.9 | 31.5 | 55.6 | 47.6 | 20.7 | 61.8 | 24.7 | 17.2 | 7.5 |
| Flora (NVIDIA, own harness) | 44.6 | 48.5 | 30.4 | 44.8 | 56.1 | 21.8 | 59.5 | 26.4 | 16.3 | 16.0 |
| Qwen3.8-27B (medium) | 44.3 | 49.1 | 31.8 | 50.2 | 50.8 | 16.4 | 62.7 | 22.8 | 12.0 | 9.6 |
| GLM-5.3-Flash (high) | 44.2 | 48.4 | 31.9 | 54.0 | 46.2 | 17.7 | 62.2 | 24.3 | 14.7 | 8.0 |
| Kimi K3 (low) | 44.1 | 47.7 | 28.6 | 53.9 | 45.1 | 19.0 | 62.1 | 24.6 | 15.7 | 7.4 |
| Qwen3.8-27B (low) | 43.0 | 48.0 | 33.0 | 49.4 | 49.5 | 16.2 | 59.9 | 20.2 | 11.2 | 9.3 |
| Mistral Large 4 (high) | 38.8 | 38.0 | 21.8 | 40.3 | 37.7 | 20.5 | 58.8 | 22.7 | 10.9 | 9.3 |
| Mistral Large 4 (low) | 38.2 | 38.3 | 22.9 | 40.6 | 38.2 | 18.8 | 57.7 | 20.3 | 9.3 | 9.2 |
| Mistral Large 4 (medium) | 37.3 | 36.6 | 19.9 | 38.2 | 36.7 | 16.9 | 59.3 | 21.2 | 7.9 | 9.2 |
| GLM-5.3-Flash (low) | 35.6 | 40.6 | 24.6 | 50.1 | 36.7 | 12.2 | 49.1 | 17.7 | 11.0 | 6.5 |

### Released clips only (compare your own runs with these)

The same runs, scored on the 45 released clips only (`released_half` in `results/published_results.json`). A score you compute on the
released clips should be compared with this table, not with the full-set tables above.

| Configuration | Score, all 45 | PA-F1 | Strict PA-F1 | Boundary F1 | Temporal F1 | Seg F1 | Joint F1 | Segments / clip | Score, operator-disjoint (30) | Score, session-disjoint (15) |
|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
| **nanoannot-1** (microagi) | **54.2** | **56.8** | **34.5** | **32.6** | **70.5** | **34.9** | **25.3** | 13.8 | 54.0 | 54.5 |
| Gemini 4 Argon (MAX) | 50.1 | 52.0 | 30.6 | 28.4 | 67.9 | 34.6 | 23.5 | 14.6 | 48.0 | 54.2 |
| Gemini 4 Argon (medium) | 50.0 | 52.2 | 30.9 | 28.1 | 67.4 | 34.6 | 23.8 | 14.4 | 48.3 | 53.2 |
| Gemini 4 Argon (low) | 49.5 | 51.6 | 31.5 | 28.2 | 66.4 | 33.5 | 22.5 | 14.4 | 48.4 | 51.6 |
| Gemini 4 Argon (high) | 47.6 | 49.4 | 27.6 | 27.8 | 63.9 | 31.6 | 21.3 | 17.6 | 45.5 | 51.9 |
| Kimi K3.1 Pro (low) | 45.7 | 47.8 | 28.1 | 22.4 | 64.8 | 27.7 | 17.0 | 13.7 | 44.0 | 49.2 |
| Kimi K3.1 Pro (high) | 45.3 | 47.5 | 28.7 | 22.1 | 64.0 | 27.6 | 16.2 | 13.8 | 44.1 | 47.6 |
| Kimi K3.1 Pro (medium) | 44.4 | 46.2 | 27.2 | 21.3 | 63.7 | 26.9 | 15.3 | 14.0 | 43.4 | 46.3 |
| Qwen3.8-Max (medium) | 44.1 | 46.1 | 25.2 | 21.7 | 62.5 | 25.6 | 16.1 | 15.2 | 41.9 | 48.4 |
| Qwen3.8-Max (low) | 44.1 | 47.0 | 28.1 | 19.3 | 63.0 | 27.1 | 17.2 | 12.7 | 42.3 | 47.6 |
| Qwen3.8-Max (high) | 43.3 | 45.0 | 24.5 | 19.8 | 63.6 | 24.5 | 15.6 | 15.1 | 40.7 | 48.5 |
| GPT-6 Astra (medium) | 42.1 | 45.7 | 28.2 | 23.5 | 53.4 | 23.8 | 18.5 | 23.1 | 38.8 | 48.8 |
| GPT-6.1 Sol (low) | 42.1 | 45.4 | 27.2 | 23.2 | 54.4 | 24.0 | 17.6 | 21.6 | 39.2 | 47.8 |
| GPT-6.1 Sol (medium) | 41.9 | 45.8 | 27.4 | 22.5 | 53.3 | 22.2 | 17.5 | 22.4 | 38.4 | 48.9 |
| Kimi K3 (high) | 41.4 | 41.3 | 21.7 | 19.0 | 63.8 | 26.7 | 14.9 | 12.1 | 40.2 | 43.7 |
| Kimi K3 (medium) | 41.0 | 42.6 | 24.3 | 17.4 | 61.5 | 25.0 | 14.6 | 10.8 | 40.0 | 43.0 |
| GLM-5.3-Flash (high) | 40.9 | 40.9 | 21.8 | 21.3 | 60.3 | 26.3 | 13.7 | 11.6 | 39.5 | 43.6 |
| Kimi K3 (low) | 40.7 | 41.6 | 22.4 | 18.8 | 60.6 | 25.5 | 13.7 | 10.7 | 39.8 | 42.3 |
| Qwen3.8-27B (medium) | 40.6 | 42.1 | 22.5 | 17.4 | 60.9 | 21.9 | 11.8 | 12.8 | 39.1 | 43.7 |
| Qwen3.8-27B (low) | 39.8 | 41.7 | 23.8 | 16.4 | 59.6 | 20.9 | 10.8 | 12.9 | 38.0 | 43.5 |
| Flora (NVIDIA, own harness) | 38.0 | 40.0 | 21.6 | 20.0 | 51.9 | 18.8 | 12.0 | 27.6 | 32.4 | 49.1 |
| GLM-5.3-Flash (low) | 32.8 | 33.9 | 16.8 | 14.0 | 49.4 | 19.1 | 9.6 | 9.7 | 32.3 | 33.8 |
| Mistral Large 4 (high) | 32.2 | 29.2 | 12.5 | 14.4 | 56.0 | 20.1 | 6.8 | 13.0 | 30.6 | 35.4 |
| Mistral Large 4 (medium) | 31.7 | 28.0 | 11.0 | 15.2 | 55.5 | 20.2 | 6.0 | 12.5 | 30.5 | 34.0 |
| Mistral Large 4 (low) | 31.4 | 27.6 | 12.0 | 15.0 | 55.2 | 19.7 | 5.6 | 12.8 | 30.1 | 34.0 |

Pairwise tournament on the released clips: the published verdicts, keeping only the released clips, refitted the same way
(500 clip bootstraps). With 15 and 30 clips the middle of the table is within the bootstrap intervals, so neighbouring ranks are not separable.

| Model (best setting) | Timing, operator-disjoint | Labels, operator-disjoint | Timing, session-disjoint | Labels, session-disjoint |
|---|---:|---:|---:|---:|
| **nanoannot-1** (microagi) | +0.81 (70%) | +1.60 (82%) | +0.48 (62%) | +0.93 (71%) |
| GPT-6 Astra (medium) | +0.25 (56%) | +1.10 (74%) | +0.73 (68%) | +0.93 (71%) |
| GPT-6.1 Sol (low) | +0.32 (58%) | +1.04 (73%) | +0.50 (63%) | +0.62 (66%) |
| Gemini 4 Argon (medium) | +0.64 (66%) | +0.60 (63%) | +0.06 (52%) | +1.00 (73%) |
| Kimi K3.1 Pro (low) | +0.22 (55%) | +0.50 (61%) | -0.29 (42%) | +0.34 (57%) |
| Flora (NVIDIA, own harness) | -0.35 (41%) | -0.34 (42%) | +0.45 (61%) | -0.04 (48%) |
| Qwen3.8-Max (low) | -0.02 (49%) | -0.06 (49%) | -0.15 (46%) | -0.15 (45%) |
| Kimi K3 (high) | -0.17 (45%) | -0.43 (40%) | -0.76 (31%) | -0.53 (37%) |
| GLM-5.3-Flash (high) | -0.06 (48%) | -1.22 (25%) | -0.39 (40%) | -0.48 (39%) |
| Qwen3.8-27B (medium) | -0.90 (28%) | -0.62 (36%) | +0.01 (50%) | -0.91 (29%) |
| Mistral Large 4 (high) | -0.75 (31%) | -2.17 (11%) | -0.65 (34%) | -1.72 (15%) |

---

## Getting the data

Access is gated: press **Request access** at the top of the Hugging Face page and fill in the form. Requests are reviewed
by hand. Once approved, download with a Hugging Face **read** token (<https://huggingface.co/settings/tokens>):

```bash
pip install -U huggingface_hub
hf auth login                                                   # paste the token once
hf download MicroAGI-Labs/MicroAnnotationBench --repo-type dataset --local-dir MicroAnnotationBench   # 5.0 GB
cd MicroAnnotationBench
```

Everything except the videos is 5 MB. To read the labels, predictions, prompts and code before pulling the clips, or to
pull one set's clips only:

```bash
hf download MicroAGI-Labs/MicroAnnotationBench --repo-type dataset --local-dir MicroAnnotationBench --exclude "data/*/videos/*"
hf download MicroAGI-Labs/MicroAnnotationBench --repo-type dataset --local-dir MicroAnnotationBench --include "data/session_disjoint_30/videos/*"
```

Scoring needs only the labels; the videos are needed only to run your own model.

---

## What is in this repository

```
data/
  operator_disjoint_59/   labels.jsonl  manifest.jsonl  videos/<clip_id>.mp4   (30 of 59 clips released, 35.3 min)
  session_disjoint_30/    labels.jsonl  manifest.jsonl  videos/<clip_id>.mp4   (15 of 30 clips released, 11.5 min)
predictions/<set>/nanoannot-1*.jsonl   nanoannot-1's published timelines (seed 1, and its 5 generation seeds)
prompts/                 the segmentation prompts and message layouts, and the three judge prompts (verbatim)
mab/                     the scorer: metrics, judges, PA-F1, Seg/Joint F1, tournament, windowing + stitch, CLI
examples/                a runnable script that evaluates any OpenAI-compatible vision model the benchmark's way (video or images input)
results/                 published_results.json (set means, tournaments) and per_clip/<set>.json (nanoannot-1, clip by clip)
tests/                   hand-checked examples for the metrics
```

### The two sets

* **Operator-disjoint set (59 clips, 30 released).** Every session *and every operator* (the person wearing the camera) that
  appears anywhere in nanoannot-1's training or validation data was removed. People, rooms, tools and habits the
  model has never seen. Read this set as the result.
* **Session-disjoint set (30 clips, 15 released).** Our standing evaluation set, triple-reviewed by annotators. Every clip comes from
  a recording session outside training, but 29 of its 30 operators also recorded training data. Read it as a check on
  direction.

Disjointness is a property of nanoannot-1's training data; it cannot be checked for API models.

### Data format

`data/<set>/labels.jsonl`, one row per clip:

```json
{"clip_id": "019e50d4-b37a-7526-afe4-1cdc15198f8f-frag-011", "num_frames": 1550, "source_fps": 30, "duration_s": 51.667,
 "task_summary": {"caption": "The person shapes a piece of wood on a table by holding it steady and carving the surface with a chisel."},
 "segments": [
   {"start_s": 0.0, "end_s": 7.8, "label": "hold the wooden piece steady on the table with the left hand; carve the wooden piece with a chisel with the right hand", "is_idle": false, "hands": "both", "flagged": false},
   ...]}
```

Segments are contiguous and in order, cover the whole clip, and include `is_idle` pauses (1 of the 168 segments on the
released session-disjoint clips, 3 of 454 on the released operator-disjoint clips). `hands` is `left`, `right`, `both` or `null`. `flagged` human segments are
excluded from scoring (the released sets contain none). `manifest.jsonl` gives each video's resolution, fps, frame count,
duration and MD5.

`predictions/<set>/nanoannot-1.jsonl`, one row per clip, is also the format your model's output must have:

```json
{"clip_id": "...", "segments": [{"start_s": 0.0, "end_s": 4.1, "label": "pick up the spatula with the right hand", "is_idle": false}, ...]}
```

`start_s` / `end_s` are seconds from the start of the clip. Every clip of the set must be present with a non-empty timeline.
`mab validate` checks exactly that: every clip of the set present, every timeline non-empty, every segment with the four fields
and `end_s > start_s`. It does not require contiguity or full coverage: time no segment covers simply earns nothing, and
overlapping predicted segments are scored as separate segments (the matching is one-to-one). Idle segments (`is_idle: true`)
are never judged and count as no prediction; their `label` is free text (the published files use `"idle"`).
Clip ids are unique across the two sets, so a file's set is the one whose `labels.jsonl` contains its ids. `--set` accepts
the aliases `59` / `operator` and `30` / `session`.

---

## Quick start: score a timeline

```bash
pip install -e .                       # or: pip install httpx numpy scipy   (av + pillow only to decode frames yourself)
export MAB_JUDGE_API_KEY=...           # PA-F1 judge, see "The judges" below
export MAB_JOINT_JUDGE_API_KEY=...     # Joint F1 judge (falls back to MAB_JUDGE_API_KEY)
python tests/test_metrics.py           # sanity check, no network
# PA-F1, strict PA-F1, Boundary F1, Temporal F1 (the default --judge-seeds 1,2,3):
mab score --set operator_disjoint_59 --predictions predictions/operator_disjoint_59/nanoannot-1.jsonl
# Seg F1@0.75 and Joint semantic F1@0.75 (--no-judge gives Seg F1 only, without network):
mab joint --set operator_disjoint_59 --predictions predictions/operator_disjoint_59/nanoannot-1.jsonl
# a cheap trial on the first 2 clips with one judge seed (cache and output kept outside the checkout):
mab score --set session_disjoint_30 --predictions predictions/session_disjoint_30/nanoannot-1.jsonl --limit 2 --judge-seeds 1 \
    --cache ../judge_cache --out ../out/trial.30.scores.json
```

`mab score` prints PA-F1, strict PA-F1, precision, recall, Boundary F1, Temporal F1, segments per clip and the set score, and
writes a JSON with every per-clip row and every judge verdict (what the judge saw for each pair and what it answered). `mab joint`
prints Seg F1 and Joint F1 with their precision and recall and writes the per-clip counts and verdicts. Without `--out` the JSON
lands next to the prediction file as `<name>.<set>.scores.json` / `<name>.<set>.joint.json`. `--limit N` takes the first N clips in
alphabetical order of `clip_id` (the same order the example script uses), `--clips a,b,c` takes chosen clips; both mark the result
`partial`. Needs Python 3.10+; `pip install -e .` installs the `mab` command (from the repo folder, `python -m mab.cli ...` also
works). Run `mab` inside the dataset folder, or pass `--root <dataset folder>` before the subcommand from anywhere. Judge verdicts
are cached, so widening a trial to the full set later only pays for the new clips.

To combine both sets:

```bash
mab score --set operator_disjoint_59 --predictions my_model.59.jsonl --out my_model.59.scores.json
mab score --set session_disjoint_30  --predictions my_model.30.jsonl --out my_model.30.scores.json
mab joint --set operator_disjoint_59 --predictions my_model.59.jsonl --out my_model.59.joint.json
mab joint --set session_disjoint_30  --predictions my_model.30.jsonl --out my_model.30.joint.json
mab headline my_model.59.scores.json my_model.30.scores.json --joint my_model.59.joint.json my_model.30.joint.json
```

The combination is `(30 × operator-disjoint + 15 × session-disjoint) / 45` over the released clips, computed before rounding (the
published full-set tables use the same rule with 59 and 30). `mab headline` prints the two set scores and the combined score with
every metric (`--out` writes them as JSON), and warns when a file is partial (a `--limit` or `--clips` trial).

---

## Running your own model

The benchmark scores the **timeline**, not the prompt or the harness, so you are free to use your own. For a result
that is comparable with the published ones, run your model the way every published configuration was run:

1. **Windows.** Each clip is processed in overlapping windows of 45 s with a 38 s stride (`mab.windows.windows`): for a
   70.5 s clip, `[0, 45]` and `[38, 70.5]`.
2. **Frames.** Decode the raw video at 6 fps from the window start, resize so the long side is 720 px, JPEG quality 85,
   nothing drawn on the frames (`mab.windows.iter_frames` / `decode_frames`). Send them in the layout the model accepts
   (`prompts/message_layout_frames_as_images.txt` shows the request bodies):
   * **video**: the window as ONE MP4 made from exactly those frames (`mab.windows.window_mp4`: libx264 CRF 18, yuv420p,
     real time at 6 fps), sent as a `video_url` data URI. Make sure the model reads all 6 frames per second: some providers
     sample fewer unless told (see the table below);
   * **images**: one `<t seconds>` text part followed by one JPEG image part per frame, 6 per second, `detail: high`;
   * **frame grids** (for models limited to 100 images per request): 4 consecutive frames packed into one 2×2 image, preceded by
     their 4 timestamps in text.
3. **Prompt.** The variant in `prompts/` for the layout; the three differ only in the sentence that says how time is shown:
   * `segmentation_prompt_mp4.txt` for the video layout;
   * `segmentation_prompt_timestamped_frames.txt` for the images and frame-grid layouts;
   * `segmentation_prompt_printed_timestamps.txt` when the timestamp is drawn on each frame (its `<fps>` placeholder is 6).
   Replace `<cs>` and `<ce>` with the window start and end in seconds (`str(round(x, 6))`). The model answers with JSON:
   `{"segments": [{"start_s", "end_s", "label", "is_idle"}, ...]}` in absolute seconds of the full clip.
4. **Validate and stitch.** Parse each window with `mab.windows.parse_window` (validates the JSON; a window whose times are
   all relative to the window start is shifted to absolute time; an unusable answer is sent again, up to 4 attempts in the
   example script), then join the windows with `mab.windows.stitch`, the coverage-preserving stitch every model's windows went through.
5. **Score** the prediction file with `mab score` and `mab joint` on both sets.

`examples/run_openai_compatible_model.py` does all of this for any OpenAI-compatible endpoint (`av` bundles its own
ffmpeg, so no system ffmpeg is needed):

```bash
pip install av pillow
export MODEL_API_KEY=...
# 2-clip trial first (alphabetically first clips; download only those videos, see "Getting the data"):
python examples/run_openai_compatible_model.py --root . --set session_disjoint_30 --input mp4 --limit 2 \
    --base-url https://openrouter.ai/api/v1 --model <your-model> --reasoning-effort low \
    --out out/mine.session_disjoint_30.jsonl
mab score --set session_disjoint_30 --predictions out/mine.session_disjoint_30.jsonl --limit 2 --judge-seeds 1
# then the whole set (the output file is resumable; failed clips are listed and re-tried on the next run):
python examples/run_openai_compatible_model.py --root . --set session_disjoint_30 --input mp4 \
    --base-url https://openrouter.ai/api/v1 --model <your-model> --reasoning-effort low \
    --out out/mine.session_disjoint_30.jsonl
mab validate --set session_disjoint_30 --predictions out/mine.session_disjoint_30.jsonl    # --limit/--clips for a trial file
mab score    --set session_disjoint_30 --predictions out/mine.session_disjoint_30.jsonl
mab joint    --set session_disjoint_30 --predictions out/mine.session_disjoint_30.jsonl
```

`--input frames` gives the images layout; `--clips id,id` runs chosen clips; `--max-uri-mb` re-encodes the MP4 at a higher
CRF when a provider caps the size of one data URI; `--extra-body` merges extra options into every request (for example
`'{"seed": 1}'` or provider routing). `<out>.usage.jsonl` records every request's tokens, reasoning tokens, cost, seconds and
MP4 size, so a 2-clip trial tells you what the full set will cost.

Published settings: every configuration ran with 5 generation seeds (1, 11, 21, 31, 41, sent in the provider's seed field where
there is one). nanoannot-1: temperature 0.6, top-p 0.95, top-k 20, no thinking. API and open-weight models: no temperature or
top-p sent (provider defaults), 32,000 max output tokens (GPT-6 Astra 8,000). Flora: NVIDIA's own two-model pipeline with its
own prompts, greedy decoding, one run, on the same 720 px / 6 fps clips; the 8 operator-disjoint clips longer than its runner's
120-s input limit were run whole with that limit raised, and its overlapping events are resolved into a non-overlapping
timeline before scoring (each segment starts no earlier than the previous one ends). In this benchmark a segment is at most 10 s
long: no human segment is longer, and every other model's prompt states the limit. Flora's own prompts do not contain it, so for
fairness, and so that Flora does not lose points for a rule it was never given, every Flora segment longer than 10 s is cut after the
run into equal consecutive pieces of at most 10 s with the same label (the run itself is unchanged).

| Model | Reasoning efforts | Model id and route | Input |
|---|---|---|---|
| Gemini 4 Argon | low, medium, high, MAX | `gemini-4-argon`, Google Vertex AI, `videoMetadata.fps = 6`, effort = `thinkingLevel` | video |
| Kimi K3.1 Pro | low, medium, high | `moonshotai/kimi-k3.1-pro` (OpenRouter) | video |
| Kimi K3 | low, medium, high | `moonshotai/kimi-k3` (OpenRouter) | video |
| Qwen3.8-Max | low, medium, high | `qwen/qwen3.8-max-0902` (OpenRouter), `"fps": 6` on the video part | video |
| Qwen3.8-27B | low, medium | open weights, self-hosted with SGLang, video read at 6 fps | video |
| GLM-5.3-Flash | low, high | open weights, self-hosted with SGLang, video read at 6 fps | video |
| GPT-6.1 Sol | low, medium | `gpt-6.1-sol` (OpenAI Batch API) | images, 270 per window |
| GPT-6 Astra | medium | `gpt-6-astra` (OpenAI Batch API) | images with the timestamp printed on each frame |
| Mistral Large 4 | low, medium, high | `mistralai/mistral-large-4-0` (OpenRouter) | frame grids, 68 per window |
| Flora | – | `nvidia/Flora-TempSeg` + `nvidia/Flora-Captioner`, self-hosted, NVIDIA's own harness | its own |

Model ids are undated: a provider can update a model behind the same id, so record the date of your run. Sampled models give a
different timeline on every run: per clip, scores move by up to ±15 points, and the published ± is the standard deviation of the
set score between the 5 generation seeds. Report the mean of several generation seeds, and state your prompt, input encoding and
routing.

---

## How the scoring works

PA-F1, strict PA-F1, Boundary F1 and Temporal F1 are computed per clip on **non-idle** segments (X predicted, Y human), then
averaged over the clips of a set. Seg F1 and Joint F1 sum their counts over all clips of a set first. Human idle segments and
flagged segments are excluded; predicted idle segments are ignored.

**PA-F1 (label quality, time-aware).** Every time-overlapping (predicted, human) pair is judged. The judge sees the
predicted label, the matched human label (PRIMARY) and the labels of the other human segments the predicted segment covers
by at least 20 frames (ALSO IN THIS TIME SPAN), and scores the pair 0–100 on whether the predicted label describes the same
action, object and hands. A predicted segment that spans two human actions may describe both without penalty; an action
from a human segment it does not cover is "out of span" and is penalised. Pairs are then assigned one-to-one, largest time
overlap first, and each assigned pair earns `score / 100`. With the credit sum C:
precision = C / X, recall = C / Y, **PA-F1 = 2C / (X + Y)**. Unmatched segments on either side earn zero.

**Strict PA-F1 (exact label agreement).** The same pairs and verdicts, but a pair earns `score / 100` only when the judge also
says the two labels describe the same action (`equivalent: true`); a roughly-right label earns nothing. No extra judge calls.

**Boundary F1 (strict timing).** A predicted segment matches a human segment only when both its start and its end are
within 20 frames (0.667 s). One-to-one, greedily by smallest total boundary error. **Boundary F1 = 2B / (X + Y)**.

**Temporal F1 (coarse timing).** Each human segment, in order, is matched to the unused predicted segment with the highest
temporal overlap-over-union if that is at least 0.5. **Temporal F1 = 2K / (X + Y)**.

**Segmentation F1@0.75 (strict timing, WGO-Bench definition).** On a scoring copy, the first predicted start is set to the
first human start and the last predicted end to the last human end. Predicted and human segments are matched one-to-one at
temporal IoU ≥ 0.75, with the largest possible number of matches. With T matches summed over the clips of a set,
**Seg F1 = 2T / (ΣX + ΣY)**.

**Joint semantic F1@0.75 (timing and label together).** A Seg F1 match counts only when the label judge also accepts the
predicted label: **Joint F1 = 2J / (ΣX + ΣY)**, never higher than Seg F1.

**Headline score** = 50% PA-F1 + 25% Boundary F1 + 25% Temporal F1. Half for what happened, half for when.

### The judges

**PA-F1 and strict PA-F1: DeepSeek V4 Flash (`deepseek-ai/DeepSeek-V4-Flash-0731`, open weights), thinking on, temperature 0.**
It is not one of the models under test and never sees the video. The published verdicts come from the FP8 weights served with
SGLang, thinking switched on through the chat template, with the judge seed (1, 2, 3) as the request seed; every timeline is
scored with the 3 judge seeds and the mean is reported (with thinking on, verdicts still vary between seeds: about ±0.5 on a
set mean, much more on a single clip). The system prompt is `prompts/pa_judge_system.txt` and the user message layout is
`prompts/pa_judge_user_example.txt`; `mab/judge.py` sends both verbatim (two internal references in the system prompt are
replaced by neutral wording).

```bash
# the published setup: your own server for the open weights (any OpenAI-compatible server; SGLang shown)
export MAB_JUDGE_BASE_URL=http://<host>:<port>/v1
export MAB_JUDGE_MODEL=deepseek-v4-flash-0731                  # the served model name
export MAB_JUDGE_API_KEY=local                                 # any non-empty value for a local server
# MAB_JUDGE_EXTRA_BODY defaults to {"chat_template_kwargs": {"thinking": true}} for such an endpoint
# or an API route of the same model (default when MAB_JUDGE_BASE_URL is unset):
export MAB_JUDGE_BASE_URL=https://openrouter.ai/api/v1
export MAB_JUDGE_MODEL=deepseek/deepseek-v4-flash-0731
```

API providers of the same weights can read slightly differently (on nanoannot-1, an OpenRouter route scored PA-F1 about 1.7
points higher than the published setup); say which judge and route you used when you report a score. Every time-overlapping
pair is judged once per judge seed: about 20 pairs per clip on the session-disjoint set and 25-30 on the operator-disjoint set.
A failed request (network or HTTP error, or an answer without a JSON verdict) is retried up to 5 times; a judge seed that still
has no verdict for a pair is dropped for that clip only (`per_clip[...].judge_seeds` says so). `--concurrency` is the number of
requests in flight per judge seed (default 25); verdicts are cached on disk (`judge_cache/seed<N>.json`), so re-scoring the same
timeline is free.

**Joint semantic F1: Gemini 3.5 Flash**, WGO-Bench's own label judge, temperature 0, up to 8,192 output tokens, thinking at the
model's default. The prompt is WGO-Bench's text-only rubric, `prompts/joint_judge_rubric.txt`, verbatim: accept when the action,
the main object and any central source or destination are right; wording and timing are ignored. The clips have no task
instruction, so the rubric's episode instruction is "not available". One call per distinct (human label, predicted label) pair.
The published verdicts came from Google Vertex AI; `mab joint` defaults to OpenRouter (`MAB_JOINT_JUDGE_BASE_URL`,
`MAB_JOINT_JUDGE_MODEL=google/gemini-3.5-flash`, `MAB_JOINT_JUDGE_API_KEY`).

### Pairwise tournament (optional)

Every pair of configurations is compared on every clip, in both A/B orders, on **Timing** (boundaries only, labels removed,
with deterministic match diagnostics) and **Labels** (label content only, timestamps removed, each candidate segment marked with
the human segments it covers). A verdict counts only when both orders agree. Scores are Bradley-Terry log strengths with 500
clip-bootstrap intervals; win rate = wins / (wins + losses). Prompts: `prompts/tournament_timing.txt`,
`prompts/tournament_labels.txt`; packet format: `prompts/tournament_packet_examples.json`. The published tournaments used the
same DeepSeek V4 Flash server, thinking on at low effort (the default request body for a self-hosted endpoint).

```bash
# your timeline against two others on the 59-clip set, both dimensions:
mab tournament --set operator_disjoint_59 \
    --arms mine=out/mine.operator_disjoint_59.jsonl nanoannot-1=predictions/operator_disjoint_59/nanoannot-1.jsonl other=path/to/another.jsonl \
    --judge-base-url http://<host>:<port>/v1 --judge-model deepseek-v4-flash-0731
```

Cost: `arms × (arms − 1) × clips × 2 dims` calls. "20/30-second tolerance" in the timing prompt means 20/30 of a second (20 frames,
0.667 s). Output: `<root>/tournament/<set>/` unless `--out` is given.

---

## Reproducing the published numbers

The tables above are full-set numbers; on the released clips, reproduce the `released_half` block of `results/published_results.json`
(same runs, same scorer, released clips only). nanoannot-1's released-clip timelines are included, so its rows reproduce end to end.
`results/per_clip/<set>.json` has nanoannot-1 clip by clip (PA-F1, strict PA-F1, precision, recall, Boundary F1, Temporal F1,
segments, and the counts behind Seg F1 and Joint F1), so a `--limit` or `--clips` trial can be checked clip by clip:
`mab compare out/my.30.scores.json --published nanoannot-1_seed1` prints the per-clip differences. Boundary F1, Temporal F1 and
Seg F1 reproduce exactly; PA-F1, strict PA-F1 and Joint F1 up to judge variation (typically within a point on a set mean). The
other configurations' timelines are not distributed; their scores are above and their settings under "Running your own model".

`nanoannot-1.jsonl` is generation seed 1 (used in the tournaments; identical to `nanoannot-1_seed1.jsonl`); the published scores
are the mean over the five generation seeds `nanoannot-1_seed{1,11,21,31,41}.jsonl`:

```bash
for s in 1 11 21 31 41; do mab score --set 59 --predictions predictions/operator_disjoint_59/nanoannot-1_seed$s.jsonl --out out/nanoannot-1.59.seed$s.json; done
python -c "import json, statistics as st; r = [json.load(open(f'out/nanoannot-1.59.seed{s}.json'))['summary'] for s in (1, 11, 21, 31, 41)]; print({k: round(st.mean(x[k] for x in r), 2) for k in ('pa_f1', 'strict_pa_f1', 'boundary_f1', 'temporal_f1', 'headline')})"
```

---

## Reporting a result

Please report, for each set and for the combination of both: the headline score, PA-F1, strict PA-F1, precision, recall,
Boundary F1, Temporal F1, Seg F1, Joint F1 and segments per clip; the judges and routes; the number of judge seeds; your prompt and
input format (or "as published"); the sampling settings; and the number of generation seeds (report their mean). For timelines
that did not come from a model run through the example script (an in-house annotator, your own pipeline), describe how they
were produced instead. To be listed on the leaderboard, open a discussion on this repository with your prediction files and
the scores JSONs: we re-score them with the published judge settings and add the row. Do not train on the benchmark clips or
their labels.

## Licence and citation

Data (videos, human labels, published timelines): **CC BY-NC 4.0**. Code and prompts: **Apache-2.0**. See `LICENSE` and
`LICENSE-CODE`. The videos show real people at work: do not attempt to identify them, and do not redistribute the clips.

```bibtex
@misc{microannotationbench2026,
  title        = {MicroAnnotationBench: scoring timed, labelled action timelines of egocentric work video against human annotation},
  author       = {Erg{\"u}zel, Ya{\u{g}}{\i}z Seymen and Adanir, {\"O}mer Burak},
  year         = {2026},
  howpublished = {\url{https://www.microagi.ai/benchmarks/microannotationbench}},
  note         = {Dataset and code: \url{https://huggingface.co/datasets/MicroAGI-Labs/MicroAnnotationBench}}
}
```

## Maintainers

MicroAnnotationBench is maintained by microagi. Questions, access requests and results for the leaderboard: open a discussion on this
repository.