Datasets:
Request access to MicroAnnotationBench
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.
Log in or Sign Up to review the conditions and access this dataset content.
MicroAnnotationBench
Scoring timed, labelled action timelines of egocentric work video against human annotation.
Blog post and results · Leaderboard · Score a timeline · Run your own model · Cite microagi · version 1.0, 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 (labels, judge-scored), Boundary F1 (strict timing), Temporal F1 (coarse timing) |
| Headline score | 50% PA-F1 + 25% Temporal F1 + 25% Boundary F1, mean over the clips of both sets |
| Published results | 16 configurations (nanoannot-1, 14 API model settings, NVIDIA's Flora pipeline), on the full sets and on the released half; nanoannot-1's timelines included |
Leaderboard (published, October 2026)
Score = 50% PA-F1 + 25% Temporal F1 + 25% Boundary F1, all 89 clips of the two sets (the blog's numbers). API models at their best reasoning setting.
This repository releases 50% of each set (15 of the 30 session-disjoint clips, 30 of the 59 operator-disjoint clips; the other half is held back to keep the benchmark
honest). The same runs on the released clips only are in Released clips only below (and in
results/published_results.json under released_half): compare your own scores with those. nanoannot-1's per-clip scores on the released clips are in results/per_clip/.
| Model | Score | PA-F1 | Boundary F1 | Temporal F1 | Segments / clip (human 13.8) |
|---|---|---|---|---|---|
| nanoannot-1 (microagi) | 54.8 | 57.4 | 32.9 | 71.5 | 13.6 |
| Gemini 4 Argon (medium) | 49.6 | 51.4 | 27.2 | 68.4 | 14.5 |
| Qwen3.8-Max (low) | 43.3 | 47.0 | 16.9 | 62.2 | 11.2 |
| Kimi K3 (low) | 43.1 | 46.8 | 18.3 | 60.5 | 10.2 |
| GPT-6.1 Sol (medium) | 40.9 | 47.1 | 18.2 | 51.3 | 21.5 |
| GPT-6 Astra (medium) | 40.6 | 46.0 | 19.8 | 50.6 | 22.0 |
| Qwen3.8-27B (low) | 39.1 | 41.0 | 14.6 | 59.6 | 11.1 |
| Flora (NVIDIA, own harness) | 31.8 | 35.5 | 16.5 | 39.5 | 25.6 |
| GLM-5.3-Flash (medium) | 30.0 | 31.4 | 11.1 | 46.2 | 8.2 |
The two sets separately, every reasoning setting (Score = the same 50/25/25 blend over the clips of that set):
Operator-disjoint set (59 clips, 30 released), all 16 configurations
| Configuration | Score | PA-F1 | Precision | Recall | Boundary F1 | Temporal F1 | Segments / clip (human 15.1) |
|---|---|---|---|---|---|---|---|
| nanoannot-1 (microagi) | 53.6 | 54.8 | 55.1 | 57.3 | 34.0 | 70.8 | 15.6 |
| Gemini 4 Argon (medium) | 46.6 | 47.8 | 47.2 | 51.2 | 25.5 | 65.5 | 16.5 |
| Gemini 4 Argon (low) | 46.5 | 46.9 | 46.2 | 50.8 | 27.8 | 64.4 | 16.8 |
| Qwen3.8-Max (low) | 43.0 | 44.1 | 46.6 | 44.5 | 20.3 | 63.4 | 13.0 |
| Gemini 4 Argon (high) | 42.8 | 44.1 | 39.0 | 54.1 | 23.5 | 59.5 | 20.4 |
| Qwen3.8-Max (medium) | 41.6 | 41.9 | 41.5 | 45.1 | 18.1 | 64.4 | 15.1 |
| Kimi K3 (medium) | 41.5 | 41.2 | 45.4 | 39.6 | 22.0 | 61.6 | 11.7 |
| Kimi K3 (low) | 41.4 | 43.4 | 47.9 | 41.8 | 18.6 | 60.3 | 11.5 |
| GPT-6.1 Sol (medium) | 38.6 | 43.3 | 36.2 | 58.5 | 18.1 | 49.6 | 24.8 |
| GPT-6 Astra (medium) | 38.0 | 42.5 | 34.8 | 58.9 | 19.3 | 47.7 | 25.5 |
| GPT-6.1 Sol (low) | 37.9 | 42.4 | 35.2 | 57.6 | 18.3 | 48.7 | 24.3 |
| Qwen3.8-27B (medium) | 36.0 | 37.3 | 40.7 | 36.5 | 11.9 | 57.5 | 12.4 |
| Qwen3.8-27B (low) | 35.9 | 36.0 | 37.9 | 36.6 | 14.4 | 57.2 | 12.9 |
| GLM-5.3-Flash (medium) | 30.9 | 31.4 | 37.2 | 29.2 | 12.5 | 48.1 | 9.8 |
| Flora (NVIDIA, own harness) | 30.7 | 34.6 | 33.2 | 46.0 | 14.7 | 38.9 | 30.5 |
| GLM-5.3-Flash (low) | 28.1 | 29.4 | 36.3 | 26.3 | 10.0 | 43.7 | 9.6 |
Session-disjoint set (30 clips, 15 released), all 16 configurations
| Configuration | Score | PA-F1 | Precision | Recall | Boundary F1 | Temporal F1 | Segments / clip (human 11.1) |
|---|---|---|---|---|---|---|---|
| nanoannot-1 (microagi) | 57.2 | 62.6 | 64.9 | 62.5 | 30.6 | 72.9 | 9.9 |
| Gemini 4 Argon (medium) | 55.5 | 58.6 | 59.4 | 59.6 | 30.8 | 74.0 | 10.6 |
| Gemini 4 Argon (low) | 53.8 | 57.2 | 58.1 | 58.6 | 26.5 | 74.2 | 10.8 |
| Gemini 4 Argon (high) | 48.5 | 55.6 | 51.3 | 65.4 | 20.1 | 62.5 | 12.5 |
| GPT-6.1 Sol (low) | 46.3 | 52.6 | 45.8 | 66.3 | 20.9 | 59.2 | 14.8 |
| Kimi K3 (low) | 46.3 | 53.4 | 59.2 | 51.5 | 17.6 | 60.8 | 7.5 |
| GPT-6 Astra (medium) | 45.8 | 53.0 | 46.0 | 68.2 | 20.7 | 56.3 | 15.0 |
| GPT-6.1 Sol (medium) | 45.5 | 54.6 | 47.0 | 70.0 | 18.5 | 54.5 | 15.0 |
| Qwen3.8-27B (low) | 45.3 | 51.0 | 54.9 | 49.9 | 15.1 | 64.3 | 7.7 |
| Qwen3.8-Max (medium) | 44.9 | 51.5 | 50.8 | 55.8 | 16.7 | 59.9 | 10.0 |
| Kimi K3 (medium) | 44.1 | 47.9 | 55.0 | 45.1 | 19.5 | 61.2 | 7.1 |
| Qwen3.8-Max (low) | 44.0 | 52.9 | 58.1 | 52.3 | 10.0 | 60.1 | 7.7 |
| Qwen3.8-27B (medium) | 42.3 | 48.7 | 52.9 | 47.9 | 14.4 | 57.5 | 7.9 |
| Flora (NVIDIA, own harness) | 33.8 | 37.3 | 40.9 | 43.0 | 19.9 | 40.7 | 15.8 |
| GLM-5.3-Flash (low) | 32.5 | 34.9 | 44.3 | 30.6 | 9.8 | 50.6 | 5.9 |
| GLM-5.3-Flash (medium) | 28.3 | 31.2 | 42.1 | 26.6 | 8.4 | 42.5 | 5.2 |
nanoannot-1 rows are the mean of 5 generation seeds; every other configuration (API models and Flora) ran once. PA-F1, precision and recall are the
mean of 3 judge seeds. The same numbers, machine-readable, results/published_results.json
and the blog post.
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 | Boundary F1 | Temporal F1 | Segments / clip | Score, operator-disjoint (30) | Score, session-disjoint (15) |
|---|---|---|---|---|---|---|---|
| nanoannot-1 (microagi) | 55.1 | 58.7 | 32.6 | 70.5 | 13.8 | 55.1 | 55.2 |
| Gemini 4 Argon (low) | 48.9 | 50.9 | 27.7 | 66.2 | 15.5 | 47.4 | 52.0 |
| Gemini 4 Argon (medium) | 48.7 | 50.9 | 26.5 | 66.6 | 15.0 | 47.1 | 52.0 |
| Gemini 4 Argon (high) | 45.2 | 47.4 | 24.2 | 61.9 | 18.1 | 44.0 | 47.6 |
| Qwen3.8-Max (medium) | 43.0 | 44.3 | 19.3 | 64.2 | 13.4 | 41.6 | 45.9 |
| GPT-6 Astra (medium) | 42.6 | 47.4 | 22.5 | 53.1 | 22.2 | 39.7 | 48.4 |
| GPT-6.1 Sol (low) | 42.2 | 46.4 | 22.5 | 53.3 | 22.0 | 38.6 | 49.2 |
| GPT-6.1 Sol (medium) | 41.9 | 47.5 | 20.7 | 52.2 | 22.1 | 39.2 | 47.4 |
| Kimi K3 (low) | 41.6 | 45.2 | 16.6 | 59.3 | 10.8 | 40.1 | 44.6 |
| Qwen3.8-Max (low) | 41.3 | 45.5 | 15.9 | 58.1 | 11.5 | 41.6 | 40.6 |
| Kimi K3 (medium) | 40.0 | 41.6 | 18.8 | 58.0 | 10.9 | 40.4 | 39.2 |
| Qwen3.8-27B (low) | 37.1 | 39.6 | 13.8 | 55.5 | 11.2 | 34.4 | 42.6 |
| Qwen3.8-27B (medium) | 36.8 | 40.6 | 11.6 | 54.3 | 11.1 | 36.2 | 37.9 |
| Flora (NVIDIA, own harness) | 31.9 | 34.5 | 17.5 | 41.3 | 28.5 | 29.0 | 37.8 |
| GLM-5.3-Flash (medium) | 30.0 | 32.3 | 10.2 | 45.2 | 8.5 | 29.7 | 30.7 |
| GLM-5.3-Flash (low) | 28.5 | 31.8 | 6.5 | 44.0 | 8.8 | 27.0 | 31.5 |
Pairwise tournament on the released clips: the published verdicts, keeping only the released clips, refitted the same way (Bradley-Terry log strength, both-order agreement, 500 clip bootstraps). Each cell is BT (win rate); higher is better; rows are sorted by the mean of the four BT values. With 15 and 30 clips the middle of the table is within the bootstrap intervals, so neighbouring ranks are not separable.
| Configuration | Timing, operator-disjoint (30) | Labels, operator-disjoint (30) | Timing, session-disjoint (15) | Labels, session-disjoint (15) |
|---|---|---|---|---|
| nanoannot-1 (microagi) | +1.12 (75%) | +2.02 (84%) | +0.96 (72%) | +1.32 (78%) |
| GPT-6 Astra (medium) | +0.24 (56%) | +1.88 (82%) | +0.59 (64%) | +0.86 (70%) |
| Gemini 4 Argon (low) | +0.78 (68%) | +1.19 (72%) | +0.62 (65%) | +0.71 (66%) |
| GPT-6.1 Sol (low) | +0.20 (54%) | +1.39 (75%) | +0.69 (66%) | +0.89 (70%) |
| GPT-6.1 Sol (medium) | +0.12 (53%) | +1.43 (77%) | +0.48 (61%) | +0.94 (71%) |
| Gemini 4 Argon (high) | +0.65 (65%) | +1.23 (72%) | +0.25 (56%) | +0.59 (64%) |
| Gemini 4 Argon (medium) | +0.71 (67%) | +0.69 (62%) | +0.74 (67%) | +0.49 (61%) |
| Qwen3.8-Max (medium) | +0.18 (54%) | -0.58 (38%) | -0.08 (48%) | +0.32 (58%) |
| Flora (NVIDIA, own harness) | -0.82 (30%) | -0.28 (44%) | -0.10 (48%) | +0.18 (53%) |
| Kimi K3 (medium) | +0.19 (54%) | -0.40 (41%) | -0.28 (43%) | -0.60 (36%) |
| Kimi K3 (low) | -0.11 (47%) | -0.40 (42%) | -0.11 (47%) | -0.60 (38%) |
| Qwen3.8-Max (low) | +0.08 (51%) | -0.49 (40%) | -0.70 (33%) | -0.59 (37%) |
| Qwen3.8-27B (medium) | -0.78 (32%) | -1.09 (29%) | -0.40 (40%) | -1.04 (27%) |
| Qwen3.8-27B (low) | -0.39 (40%) | -1.60 (21%) | -0.70 (33%) | -0.69 (34%) |
| GLM-5.3-Flash (medium) | -0.95 (28%) | -2.28 (12%) | -1.12 (25%) | -1.36 (21%) |
| GLM-5.3-Flash (low) | -1.21 (23%) | -2.71 (8%) | -0.84 (30%) | -1.44 (20%) |
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/*"
From Python: huggingface_hub.snapshot_download("MicroAGI-Labs/MicroAnnotationBench", repo_type="dataset", local_dir=..., allow_patterns=[...]). git clone https://huggingface.co/datasets/MicroAGI-Labs/MicroAnnotationBench with Git LFS
installed also works. 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 every model received, and the two judge prompts (verbatim)
mab/ the scorer: metrics, judge, PA-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) and per_clip/<set>.json (every published configuration, 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=... # OpenRouter key (default judge route), see "The judge" below
python tests/test_metrics.py # sanity check, no network
# reproduce a published row (the default --judge-seeds 1,2,3, comma-separated; about 884 judge requests per seed on the 30 released operator-disjoint clips):
mab score --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, 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, what it answered, and the
response's usage: reasoning tokens and cost). Without --out the JSON lands next to the prediction file as
<name>.<set>.scores.json; --out folders are created. --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.
The judge's verdicts for a trial are cached, so widening it to the full set later only pays for the new clips.
To get the headline score over both sets, score both and combine them:
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 headline my_model.59.scores.json my_model.30.scores.json
The combination is (30 × operator-disjoint + 15 × session-disjoint) / 45 over the released clips, computed before rounding, which equals the mean
over all 45 released clips (the published table uses the same weights on the full sets, 59 and 30). mab headline prints the two set scores and the combined score, PA-F1, precision, recall, Boundary F1,
Temporal F1 and segments per clip (--out writes them as JSON), and warns when either file is partial (a --limit or
--clips trial). Use the same --cache folder for a trial and the full run that follows it (or the default for both), or the
trial's verdicts are not reused.
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 one of two layouts (prompts/message_layout_frames_as_images.txtshows both 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 so the file's own clock starts at the window start), sent as avideo_urldata URI. Gemini 4 Argon, Qwen3.8-Max, Qwen3.8-27B, Kimi K3 and GLM-5.3-Flash were run this way; - images: one
<t seconds>text part followed by one JPEG image part per frame, 6 per second,detail: high(GPT-6.1 Sol, through OpenAI's Batch API; also nanoannot-1's own input layout).
- video: the window as ONE MP4 made from exactly those frames (
Prompt. The variant in
prompts/for the layout; the three differ only in the sentence that says how time is shown:segmentation_prompt_mp4.txtfor the video layout;segmentation_prompt_timestamped_frames.txtfor the images layout;segmentation_prompt_printed_timestamps.txt: the timestamp drawn on each frame (GPT-6 Astra, an earlier run; its<fps>placeholder is the frame rate, 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; a window whose answer is unusable is sent again, up to 4 attempts in the example script, and a clip that still fails is re-tried on the next run), then merge the windows withmab.windows.stitch, the coverage-preserving stitch every model went through.Score the resulting prediction file with
mab scoreon 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
--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 (for example provider routing) into every
request. <out>.usage.jsonl records every request's tokens, reasoning tokens, cost (as the provider reports it), seconds and MP4
size, so a 2-clip trial tells you what the full set will cost. The released session-disjoint clips have 24 windows, the released
operator-disjoint clips 64 (mab windows <duration> prints a clip's plan).
Published sampling settings: nanoannot-1 at temperature 0.6, top-p 0.95, top-k 20, no thinking. API models: no temperature or top-p sent (provider defaults), reasoning effort low / medium (and high for Gemini 4 Argon), 32,000 max output tokens, one run each. 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.
| Configuration | Model id | Input |
|---|---|---|
| Gemini 4 Argon low / medium / high | google/gemini-4-argon (OpenRouter) |
video |
| Qwen3.8-Max low / medium | qwen/qwen3.8-max-0902 (OpenRouter) |
video |
| Qwen3.8-27B low / medium | qwen/qwen3.8-27b (OpenRouter) |
video |
| Kimi K3 low / medium | moonshotai/kimi-k3 (OpenRouter) |
video |
| GLM-5.3-Flash low / medium | z-ai/glm-5.3-flash (OpenRouter) |
video |
| GPT-6.1 Sol low / medium | gpt-6.1-sol (OpenAI Batch API) |
images, 270 per window |
| GPT-6 Astra medium | OpenAI API, earlier run | frames with printed timestamps |
| Flora | nvidia/Flora-TempSeg + nvidia/Flora-Captioner, self-hosted |
its own harness and prompts |
Model ids are undated: a provider can update a model behind the same id, so record the date of your run. API models sample (no temperature or seed is sent), so a re-run gives a different timeline. Per clip, scores move by up to ±15 points. On a set mean, one run varies by about ±4 points on the 30-clip set and ±2.5 on the 59-clip set (one standard error), and by about 1.4 times that on the released halves. Judge a reproduction on the combined score over both sets, and for a model you sample, report the mean of several generation seeds. State your prompt, input encoding and routing in your report.
How the scoring works
All three metrics are computed per clip on non-idle segments (X predicted, Y human), then averaged over the clips of a set. 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.
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).
Headline score = 50% PA-F1 + 25% Temporal F1 + 25% Boundary F1. Half for what happened, half for when.
The judge
The PA-F1 judge is DeepSeek v4 Flash with thinking enabled, temperature 0, which is not one of the models under test.
It never sees the video. Every timeline is scored with 3 judge seeds (1, 2, 3) 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 published runs went
through OpenRouter pinned to one provider (the scorer's default, below), with the judge seed passed as the request seed. The
model thinks by default on that route, and every verdict record keeps the response's reasoning_tokens. 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 were replaced by neutral wording; re-judging nanoannot-1 with both
versions gave PA-F1 63.3 and 63.8, inside the seed spread.
Configuration:
export MAB_JUDGE_API_KEY=... # required
export MAB_JUDGE_BASE_URL=https://openrouter.ai/api/v1 # default
export MAB_JUDGE_MODEL=deepseek/deepseek-v4-flash-0731 # default
# MAB_JUDGE_EXTRA_BODY='{"provider": {"order": ["GMICloud"], "allow_fallbacks": false}}' # default on OpenRouter
Any OpenAI-compatible endpoint works (--judge-base-url, --judge-model), including DeepSeek's own API
(https://api.deepseek.com/v1, model deepseek-v4-flash; thinking is enabled automatically). Using a different judge model
gives numbers that are not comparable with the published ones; say which judge you used when you report a score.
Cost and time: every time-overlapping (predicted, human) 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 (nanoannot-1 on the released clips: 293 and 884 requests per seed;
a model that over-segments has more). A call costs about $0.0008 on average. With 3 judge seeds, the released session-disjoint
clips cost about $1.7 and take about 10 minutes; the released operator-disjoint clips cost about $5 and take 25-30 minutes (at
the default concurrency). A failed request (network or HTTP error, or an answer without a JSON verdict) is retried up to 5 times,
with the same token budget and retry policy as the published runs. A judge seed that still has no verdict for a pair is dropped
for that clip only (per_clip[...].judge_seeds and failed_seeds say so). --concurrency is the number of requests in flight
per judge seed (default 25, so 75 with 3 seeds; keep the total within your provider's rate limit); --clip-parallelism
(default 4) is how many clips are judged at a time. Progress lines show an ETA, and <out>.partial.json is rewritten after
every finished clip. Verdicts are cached on disk (judge_cache/seed<N>.json), so re-scoring the same timeline is free and two
scorers may share one cache folder. Use --cache and --out to keep the cache and the scores outside the dataset checkout.
Pairwise tournament (optional)
Besides the three metrics, the blog reports head-to-head tournaments: 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.
# your timeline against three published configurations on the 59-clip set, both dimensions:
mab tournament --set operator_disjoint_59 \
--arms mine=predictions/mine.operator_disjoint_59.jsonl nanoannot-1 other=path/to/another_timeline.jsonl \
--judge-base-url https://api.deepseek.com/v1 --judge-model deepseek-v4-flash
Cost: arms × (arms − 1) × clips × 2 dims calls (4 arms on the 30 released operator-disjoint clips = 720 calls, about $0.0006 each). The published
tournaments used DeepSeek v4 Flash with thinking at low effort through DeepSeek's API; the tournament sends its own fixed
request body (mab.tournament.tournament_extra_body), not MAB_JUDGE_EXTRA_BODY. The tournament prompts are verbatim;
"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 instead
(same runs, same scorer, released clips only). nanoannot-1's released-clip timelines are included, so its rows reproduce end to end.
predictions/<set>/ holds nanoannot-1's published timelines. results/published_results.json (set means of every
configuration, the leaderboard above) and results/per_clip/<set>.json (nanoannot-1 clip by clip: PA-F1, precision, recall,
Boundary F1, Temporal F1, segments, each the mean of the 3 judge seeds) were computed from the original judge runs, 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 (scores JSON and per-clip file are both on the 0-100 scale). Re-scoring a published file with mab score reproduces Boundary F1
and Temporal F1 to ±0.01 (per-clip rounding in the published tables) and PA-F1 up to judge variation (typically within a
point on a set mean: the judge thinks before answering, so identical settings do not give identical verdicts). The other
configurations' timelines are not distributed; their set means are above and the settings that produced them are under
"Running your own model".
For nanoannot-1, nanoannot-1.jsonl is generation seed 1 (used in the tournaments; identical to nanoannot-1_seed1.jsonl);
the published PA-F1 / Boundary F1 / Temporal F1 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', 'boundary_f1', 'temporal_f1', 'headline')})"
Every API configuration ran once.
Reporting a result
Please report, for each set and for the combination of both: PA-F1, precision, recall, Boundary F1, Temporal F1, segments per clip and the headline score; the judge model and route; the number of judge seeds; your prompt and input format (or "as published"); and the sampling settings. 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. One generation run per configuration is the published convention for API models; for a model you sample, report the mean of several generation seeds and say how many. 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}}
}
Changelog
- 1.0 (2026-10-21) — initial release: 45 clips, 50% of each of the two sets (the other half is held back), human timelines, nanoannot-1's timelines (seed 1 and five generation seeds), the scorer (PA-F1, Boundary F1, Temporal F1, headline), the judge and segmentation prompts, the pairwise tournament, published set means and per-clip scores, and a runner for OpenAI-compatible models (video and image input).
Maintainers
MicroAnnotationBench is maintained by microagi. Questions, access requests and results for the leaderboard: open a discussion on this repository.
- Downloads last month
- 47