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.

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.

MicroAnnotationBench

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

Blog post · Leaderboard · Score a timeline · Run your own model · Cite 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: 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):

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:

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:

{"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:

{"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

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:

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:

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].
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.
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.
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.
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):

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).

# 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).

# 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:

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.

@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.

Downloads last month: 84

Total file size:

4.96 GB