MicroAGI-Labs/g1d-grip-vision

G1-D grip and visual-servo vision eval (run32)

This is a small, hand-verified evaluation set of real robot camera frames. It tests whether off-the-shelf vision classifiers can answer the questions a G1-D humanoid's grasp loop asks:

• Is this hand holding the crate handle, or only hovering over it?
• Does this wrist view look like the GOOD reference or the BAD one?
• Where is the bar in the wrist image?
• Simple scene facts.
• Is the floor along a planned base route clear (route_clear, head camera with the route overlaid)?

The set was built to compare the OpenAI Decisions API (gpt-6-luna) with classifier.dev (imajev-4b).

Public, CC BY 4.0. The images show the MicroAGI lab, and some frames show people; faces are blurred in route_clear. grip_reference holds 14 rendered SIM wrist frames for the sim-vs-real domain gap, and route_clear holds 22 scored SIM head frames from crate-fall runs.

Robot and cameras

• Robot: a real Unitree G1-D. It has a wheeled base, a vertical lift, waist yaw and pitch, two 7-DoF arms, and Revo2 6-DoF hands.
  • The hands have fingertip normal-force sensors. The thumb sensor is unavailable on this robot.
• Control: the frames come from run32 (2026-10-08) of the Astra agent. The agent drove the robot through the Thor hardware gateway, and an operator approved every action. The tasks were:
  1. pick the white bag from a new table and put it into the grey crate;
  2. pick up the crate by its two black handle bars;
  3. carry it to the blue roller shelf and set it down.
• Camera format: all frames are 640x480 JPEGs, saved by the gateway at each observation oNNN.
• ego_left (head): the left camera of the head stereo pair. The robot's LEFT hand appears on the LEFT side of the image and its right hand on the right. The head has a systematic downward tilt of about 5 degrees.
• left_wrist / right_wrist: these cameras are mounted under each wrist and look along the hand axis. Keep these caveats in mind:
  • The hand and fingers fill the top and centre of the frame as dark silhouettes seen from below. The bright background drives the auto-exposure, so the black fingers and the black bar often merge. The bar is easily hidden by the fingers. This is why single wrist images are weak evidence on their own.
  • Image axes are camera axes, not robot or world axes. "Top" in a wrist image points roughly along the fingers, and the mapping to robot motion changes with wrist roll and pitch. The left and right views are roughly mirror images of each other.
  • When the robot travels, the wrist rolls about ±1.5 rad so the cameras look sideways. While it carries the crate, the wrists are tilted "fingers up". Views from different task phases (on the table vs at the shelf) therefore look different, even with the same grip.
  • The background changes a lot between scenes: a wooden table, a white wall, or the blue roller shelf and the room beyond it.

Configs

All configs have a single test split. Images are stored as datasets.Image, using the original JPEG bytes.

grip_state — 56 rows (28 frames x 2 hands)

Each row is one (frame, hand) pair. It holds ego_image plus that hand's wrist_image. The label is one of gripping, hovering, away or uncertain, and it is defined relative to the row's target:

label	meaning
gripping	the digits are closed on the target and actually hold it (load carried, or contact confirmed)
hovering	the hand is at or just above the target but does not hold it. This includes hands that are open over it, open in contact position, or closed on air or on top of the bar (missed grasps)
away	the hand is not near the target and not engaged with it (the spare hand, raised clear)
uncertain	no single label is defensible (kept, flagged, and not scored)

phase	target	frames	gripping	hovering	away	uncertain
bar_grip	crate handle bar	o92 o94 o99 o101 o103 o104 o106 o108-o116 o118 o120 o122	27	9	0	2
bag_pinch	white bag	o54 o55 o56 o58 o59 (both hands), o60-o66 (right hand)	6	3	5	0
wall_pinch	crate near wall	o60 o63 o65 o66 (left hand)	2	2	0	0
total			35	14	5	2

Other fields:

• obs, run, side, phase, target
• label_source: coordinator (20 rows) or extended (36 rows)
• source_notes: the evidence for the label (action ids, operator answers)
• is_wrist_reference: true for the reference frames o92 and o112
• last_action_id
• fingers_normalized: thumb, thumb_aux, index, middle, ring, pinky; 0 = open
• fingertip_force_n: thumb, index, middle, ring, pinky, in N. The thumb value is always null. The right pinky reads about 0.7 N as a sensor offset even when the hand is open.
• lift_height_m
• baseline columns (see below)

grip_reference — 56 rows (42 real + 14 sim)

Each row holds good_ref_image, bad_ref_image and test_image, all from the same wrist camera (same side). The label is good (the test hand holds the target) or bad. label_3way uses the space good / bad / notvisible (the target is not visible in the test image). Every current row is visible, so label_3way equals label. domain is real or sim.

phase	references (same side)	tests	good	bad
bar_grip	GOOD o112 / BAD o92 (left and right), as used in the experiments	16 frames x 2 sides (o94-o120, without the references and without o122)	25	7
bag_pinch	GOOD o58 R / BAD o55 R (look reference library seeds)	o54 o56 o59 o60 o63 o65 o66, right hand	5	2
wall_pinch	GOOD o65 L / BAD o63 L (look reference library seeds)	o60 o66, left hand	1	1
bar_grip, sim	REAL GOOD o112 / BAD o92, same side	7 sim observations x 2 sides (see below)	10	4

• Real bar_grip sanity row: it also includes o92 L, the BAD reference itself (test_is_reference = true), because the coordinator scored it with the 3-way prompt.
• Sim rows: run is sim/<batch>/<run> and obs is the sim observation.
  • Source: simbatch/<v4h|v4i>/<run>/gateway/*/observation_NNNN/<side>_wrist.jpg.
  • GOOD (bar seated in the curled fingers): v4h run2 o4, v4h run3 o6 and o31, v4i run3 o6 and o49.
  • BAD (hovering): v4h run3 o3, v4i run3 o44.
  • The labels are the coordinator's sim ground truth. v4h run3 o6 right was also verified by eye.
  • The bar is visible in all 14 frames.
• Baseline probability columns (p_good_old_prompt, p_good_geometry_prompt_2way, p_*_geometry_prompt_3way, with baseline_prompt_sources): see Sim vs real domain gap.

same_scene_as_refs = false marks o118 and o120 (both sides) and every sim row. These frames show the crate being carried at the shelf, which is a different pose and background family from the references. grip_state_label keeps the 4-way label.

bar_position — 10 rows

These images come from servo/: the o112 right-wrist frame shifted by a known number of pixels, with the uncovered area filled with grey 128.

• v-160 … v+160 shift the image vertically (dy); h-200 … h+200 shift it horizontally (dx). Positive values move the content right or down.
• The ground-truth bar centre is (430 + dx, 235 + dy). The reference centre (430, 235) was set by eye on the unshifted frame (about ±15 px). The shifts themselves are exact.
• bar_bbox_xyxy is the visible bar extent, (320, 170)-(540, 285) shifted the same way. bar_visible_fraction gives how much of the bar is still in frame: h+200 has only 55% of the bar in frame.
• The 3-bin labels split the 640x480 frame into thirds: top/middle/bottom at y = 160 and 320, and left/centre/right at x = 213.3 and 426.7. label is the bin on the row's axis.
• on_bin_boundary is set when the centre is within 25 px of a bin edge on that axis. This applies to v-80, v+80, h-200 and h+0. Note that h+0 (x = 430) falls in right by 3 px, and v+0 and h+0 are the same image.
• scripts/make_servo_shifts.py regenerates servo/ byte for byte (PIL, paste on grey 128, JPEG q = 90).

scene_facts — 42 rows

Easy predicates on the head image of 9 frames, labelled by eye. A predicate is left out for a frame whenever it is not clear-cut. For example, wooden_table is omitted at the shelf because only a table corner is visible there.

predicate	question	true	false
bag_in_container	A white bag is inside the grey container.	7	1
wooden_table	A wooden table top is visible.	7	0
two_robot_hands	Two robot hands are visible.	7	2
person_visible	A person is visible.	1	8
indoors	The image was taken indoors.	9	0

route_clear — 75 rows (58 scored + 17 AMBIGUOUS)

This config tests the look route-clear check. Each row is a head ego_left frame with a planned base route drawn on it. The check answers one of CLEAR / OBSTACLE / AREA NOT VISIBLE.

Columns

• image: the overlay the model sees (route-overlay --clean): yellow boundary lines and light shading over the floor area the base footprint (±0.27 × ±0.26 m) sweeps. The area includes turn arcs and rear corners, minus the start footprint.
• raw_image: the frame without the overlay.
• route: for example drive:0.4 turn:-45 drive:1.4. Turns are in degrees, + = left. Negative drive = reverse.
• label: CLEAR, OBSTACLE, NOT_VISIBLE or AMBIGUOUS.
• scored: false for AMBIGUOUS rows.
• domain: real or sim.
• note: the reason for the label.
• visible_frac: the share of the swept floor that projects into the image.
• visible_part: for NOT_VISIBLE rows, what the visible part shows.
• state_ref: the source frame and state.
• faces_blurred: true where faces were blurred.

domain	CLEAR	OBSTACLE	NOT_VISIBLE	AMBIGUOUS
real (run20, run28, run32, run33)	14	15	7	12
sim (crate-fall runs v4c run1/run4, v4d run3, v4h run1, v4i run2)	5	10	7	5

Labels (by eye, on the full-resolution overlay)

• OBSTACLE: anything inside the outline that is about 3 cm tall or more and that the base cannot drive over, or a loose item that could catch a wheel. Examples in this set:
  • table, shelf and stool legs; a flight case; a lamp-stand base; another robot;
  • a box; shoes; a person's foot; a foot platform;
  • in sim, the fallen crate and bag.
  • A route under the blue roller shelf's front also counts (shelf base / roller-bed front).
• CLEAR: only floor, flat tape and markings, a flat cable, or the floor-mat edge (a step of about 4.5 cm, which the base drives over).
• NOT_VISIBLE: visible_frac < 0.9, which is the tool's coverage gate (in-place or sharp turns, reverses).
  • It also covers cases where the robot's own held crate hides much of the swept floor: 6 rows with visible_frac 1.0, because the projection does not model self-occlusion.
• AMBIGUOUS (excluded from scoring):
  • an object exactly on the outline;
  • a route ending under a table top between its legs with no floor obstacle in between, because it depends on the check's height band.

Other notes

• Real frames were rendered with the robot's body model at the frame's state. Sim frames use the pod's sim body bundle 9e6d0224b1f5a2fc and the camera-config intrinsics; the tool handles this automatically.
• Privacy: faces are blurred in this public copy, in 6 rows (run33 o9 and o13). The blurred areas are away from every outline.
• The full local set lives in ~/g1d-astra/datasets/route_clear: state JSONs, annotated overlays and the labels script. It is calibrated with look/validate/eval_route.py on its cases.jsonl.

How labels were verified

1. Coordinator labels (20 grip_state rows). The coordinator checked these by eye, and the next test lift confirmed them:
   • o92 and o94: both hands hovering. o92 is the BAD wrist reference.
   • o101: left gripping; right hovering (the bar is visible below and in front of the fingers, not held).
   • o104: left gripping; right not seated.
   • o108: both gripping (confirmed by the a65 test lift).
   • o112: both gripping (GOOD wrist reference).
   • o115: carrying.
   • o118 and o120: carrying at the shelf.
   • o122: uncertain.
2. Extended labels (36 rows). These were added for this dataset only where three independent sources agree:
   • the images (head and wrist, inspected by eye);
   • the run32 action log: ledger.jsonl decisions and outcomes, chain responses with the operator's YES/NO answers to pre-step questions such as "Are the thumb and at least three fingers in the bag film?" or "Is the right bar seated…?", operator rejections such as "thumb is in front of the bar" or "hand needs to go lower particularly pinky", and notes.md;
   • finger readings in oNNN-1_state.json. Examples: the left grip closed at o95 and its readings stay identical to o122; right-hand contact limits and fingertip forces after the c64 close; bag-pinch contact of about 0.6 N.
3. What confirmed the grips:
   • From o108 on, every "gripping" bar label is backed by the crate actually being lifted and carried to the shelf with no re-grasp.
   • Bag "gripping" (o58-o66) is backed by the bag hanging from the right hand (test lift, then held clear).
   • Wall pinch (o65, o66) is backed by the operator's YES and by the crate sliding 10 + 15 cm.
4. Never guessed. Anything that did not meet this standard was left out or labelled uncertain (see below).

Known ambiguities and exclusions

• o122: uncertain (both hands). The crate was set down on the roller bed with the lift only. The fingers are still closed around the bars, but the load rests on the rollers. The hands released at c77, and o124 shows them withdrawn.
• "Closed but missed" counts as hovering. This applies to o101 R and o103 R. A finger-closure proxy would call these gripping, and classifier.dev's ego answer did exactly that on o101 R at 0.94.
• o103 R: the right fingers closed on air after the crate was pushed around the left grip. The bar only shows at the bottom edge of the wrist view.
• o118 and o120: the scene and pose differ from the references, and the models were unsure on o120 R. The truth is not in doubt, because the crate was being carried.
• Left hand during the bag pick (o54-o59): away, relative to the bag. The spare left hand was raised above the crate end, close to the crate's handle in the head view. A bar-grip question on those frames might reasonably answer hovering, so only use these rows with the bag as the target.
• bar_position boundary rows: v-80, v+80, h-200 and h+0 sit on bin boundaries. h+200 has the bar half out of frame.
• Excluded frames:
  • o93, o95 and o98 are left out. Their state is clear from the log, but they fall outside the requested o99-o122 extension window (o92 and o94 are included as coordinator labels).
  • o124 onward (release, rest, table survey) is left out.
  • o115-2, o50-2 and o91-2 (duplicate captures) are left out.
  • The wrist-crop images are left out.
  • o53 and o73 are left out (o73 was taken during the thermal safe-hold recovery).

Baselines (recorded by the coordinator, look/experiments/NOTES.md, 2026-10-08)

Baseline columns are filled only where NOTES.md ties a result to a frame. A null value means not recorded, not wrong.

• grip_state.baseline_{openai,cdev}_ego_choice/conf: per-hand choice on the ego image, for o94, o101, o108 and o115.
• grip_reference.baseline_openai_compare/p_good and baseline_cdev_same_as_good/conf.
• bar_position.baseline_openai_choice/conf and baseline_cdev_choice.

task (run32 real frames)	OpenAI Decisions gpt-6-luna	classifier.dev imajev-4b
Ego, one choice per hand (gripping/hovering/away/unclear), o94/o101/o108/o115	7/8; misses o108 R (hovering 0.53 vs gripping 0.40); confidence 0.4-0.7	6/8; o94 R and o101 R confidently "gripping" 0.94 (wrong, right-hand bias)
Same, plus o122 (10 hands)	8/10, including the exact o101 split	not run
Wrist reference comparison, bar grip (left: o94 BAD, o101/o104/o108/o115 GOOD; right: o94/o101/o104 BAD, o108/o115 GOOD)	10/10, p 0.92-1.00 (3 images: GOOD o112, BAD o92, test); swapped A/B order 6/6, no order bias	9/10 (2-image limit: GOOD o112 + test, same/different); R o94 wrong at 0.65, L o115 weak at 0.59
Same, shelf carry o118/o120 (truth GOOD)	0.99, 0.81, 0.96 and 0.50 (o120 R)	not run
Wrist image alone, choice	5/8, low confidence	not run
Ego + both wrists, one request	6/8, lower confidence than ego alone	not run (2-image limit)
Scene facts (bag, table, two hands, no person, indoors)	reliable: 0.0 / 0.95-1.0	not run
Bar position, vertical (5)	5/5 monotonic: v-160 top 0.96, v-80 top 0.39 (boundary), v0 middle 0.60, v+80 middle 0.96 (boundary), v+160 bottom 0.41	weaker: v+160 "middle" (wrong)
Bar position, horizontal (5)	h-200 left 0.84 (truth centre, boundary), h-100 centre, h0 centre (truth right by 3 px, boundary), h+100 right 0.73, h+200 centre 0.47 (wrong, bar half out). Strict 2/5, off-boundary 2/3	h+100 and h+200 "none" (wrong)
Latency	0.23 s median per call (keep-alive, 1 image, 1 question); about 0.4 s for ego scene facts (1-2k tokens); 0.5-0.8 s for 3-image comparisons; about 0.25 s per servo call	0.77 s median wall (anonymous, keep-alive), 0.66 s (0.55-1.02) with a workspace key; the server model takes only 51-108 ms, and about 0.5 s is edge overhead (Server-Timing: request_read 473 ms, account_admit 494 ms); first call 1.8 s
API notes	detail: high	max 2 images and 1 MB per request; returns unknown_probability and abstained; share_data defaults to TRUE: always send false

A separate validation of the production look tool lives in ~/g1d-astra/look/VALIDATION.md. It used a reference-comparison pipeline with a head-view veto, scored on sim frames plus run32. It is a different pipeline from these baselines.

Sim vs real domain gap

Setup. Each sim wrist frame (the test, image C) is judged against the real run32 wrist references of the same side: GOOD o112 and BAD o92. Three prompts were run with the Decisions API (gpt-6-luna, detail: high). Their full text is below and in prompts/.

• Probability columns: p_good_old_prompt, p_good_geometry_prompt_2way, and p_good/p_bad/p_notvisible_geometry_prompt_3way.
• baseline_prompt_sources: records per row which prompt file and script each value came from.

YES / NO rule: YES only if p_good ≥ 0.6, counted from those columns.

prompt	domain	YES on GOOD	false YES on BAD	argmax accuracy
old (compare.py)	sim (14)	7/10	1/4 (v4i o44 L at 0.62)	10/14
geometry 2-way (compare_p.py)	sim (14)	7/10	0/4	11/14
geometry 2-way	real (9)	5/5	0/4	9/9
geometry 3-way (compare3.py)	sim (14)	7/10 (left 5/5, right 2/5)	0/4	10/14
geometry 3-way	real (12, including o92 L, o118 R, o120 R)	6/7 (miss: o120 R at 0.43)	0/5	11/12

Findings

1. The domain gap is real, but it fails safe with the geometry prompt.
   • With the geometry prompt, every sim BAD frame scores low: p_good ≤ 0.50 with the 3-way prompt and ≤ 0.21 with the 2-way prompt.
   • The misses are GOOD frames scored low, which is a false NO, not a false YES.
2. The old prompt produced one false YES. It was compare.py, which mentions neither rendering style nor geometry, and it scored sim v4i o44 L (BAD) at 0.62. The geometry prompt lowers that to 0.06 (2-way) and 0.09 (3-way). It tells the model to ignore rendering, colour, lighting and background, and to judge only the bar position relative to the fingers: close under them with the fingertips curled around, or lower with a gap.
3. The right-hand sim GOOD frames are the weak spot.
   • v4h run3 o6 R scores 0.15 (2-way) and 0.41 (3-way), even though it was verified GOOD by eye.
   • v4i run3 o6 R scores 0.31 and 0.21, and v4h run2 o4 R scores 0.63 and 0.43.
   • The left-hand sim GOOD frames all pass with the 3-way prompt (0.67-0.86).
   • Real right-hand frames outside the reference pose family also drop: o120 R scores 0.43.
4. The geometry prompt keeps real-frame performance. It separates the real frames cleanly: GOOD 0.92-1.00 except o120 R; BAD ≤ 0.04.

Decision: drop UNSURE and answer YES / NO / NOT VISIBLE.

• The earlier look rule had an UNSURE band at 0.3-0.7. It is replaced by:
  • YES if p_good ≥ 0.6;
  • NOT VISIBLE if the 3-way notvisible option is the argmax (the bar is hidden or out of view);
  • NO otherwise.
• This gave 0 false YES on these sets with the geometry prompts: 4 sim BAD and 4-5 real BAD. The old prompt had 1/4 sim false YES.
• The cost is false NOs on hard GOOD frames, mainly right-hand sim and off-pose real frames. A false NO only costs a re-check or re-seat, while a false YES risks lifting a crate that is not held.
• eval.py applies this rule to every grip_reference verdict and reports false-YES per domain.

Prompts (verbatim; {side} = left / right)

Content order (all three prompts): INTRO; then "Image A (GOOD example: the black handle bar is held inside the curled fingers):" followed by the GOOD reference; then "Image B (BAD example: the black handle bar is NOT held by the fingers):" followed by the BAD reference; then "Image C (the one to judge):" followed by the test image.

Choices:

• good: "image C matches image A: bar held inside the curled fingers"
• bad: "image C matches image B: bar not held by the fingers"
• 3-way only, notvisible: "the handle bar is not visible in image C (hidden, out of view)"

Old (prompts/old_2way.json, compare.py):

• INTRO: "Three photos from the same camera under the {side} wrist of a robot, looking along its hand (the dark shapes are the hand and fingers seen from below)."
• Q: "Regarding how the hand holds the black handle bar, is image C more like image A (GOOD, bar held in the fingers) or image B (BAD, bar not held)?"

Geometry 2-way (prompts/geometry_2way.json, compare_p.py with the INTRO/Q env variables):

• INTRO: "Three images from the camera under the {side} wrist of a humanoid robot, looking along its hand toward the fingertips (the large dark shapes at the top are the hand and fingers seen from below). Images A and B are real photos; image C may be a computer-rendered SIMULATION of the same robot (flat colours, different lighting and textures). Ignore all rendering, colour, lighting and background differences and judge ONLY the geometry of the long black handle bar relative to the fingers. GOOD (held): the bar crosses the image close under the fingers, the fingertips curl around or past it, no gap between bar and fingers. BAD (not held): the bar is lower in the image, separated from the fingers by a clear gap (or absent), and the fingers point straight down or open."
• Q: "Judging only the bar-to-finger geometry (ignore rendering style), is the handle bar in image C held like image A (GOOD) or not held like image B (BAD)?"

Geometry 3-way (prompts/geometry_3way.json, compare3.py):

• INTRO: same as the 2-way, without "(or absent)".
• Q: "Judging only the bar-to-finger geometry (ignore rendering style): in image C is the handle bar held like image A (GOOD), not held like image B (BAD), or not visible at all?"
• Choices: good, bad, notvisible.

Reproduction check. The reconstructed 3-way prompt, run through eval.py, gave the coordinator's values to two decimals on sim v4h run2 o4 L/R and v4h run3 o31 L: 0.86, 0.43 and 0.68.

Prompt and wording findings

1. Use plain visual vocabulary. "Grey container" and "black bar" score 0.87-0.99, with bars at 0.92 and gripping at L 0.89 / R 0.85 (correct). "Crate" and "handle" scored badly: grey crate 0.35, handles 0.12, holding 0.01 (wrong). Adding a scene-context paragraph made the answers worse (0.71 / 0.34).
2. Ask one choice question, not parallel predicates. Independent predicates for mutually exclusive states contradict each other within the same request. On o108 the model answered gripping 0.89 and hovering-not-gripping 0.92 and not-touching 0.94. Ask one choice question per hand instead (gripping / hovering / away / unclear), name the hand by image side ("the robot hand on the LEFT of the image"), and put the ego view first.
3. Compare against references for the wrist cameras. A GOOD and a BAD example from the same side and task phase, then the test image, with one choice question ("is C more like A or B"). This went from 5/8 (wrist alone) to 10/10 at 0.92-1.00. It drops to about 0.5 when the scene or pose differs from the references, so keep references per side and per phase (bar grip, bag pinch, wall pinch, release), ideally from the same pose family. The original rule treated 0.3-0.7 as UNSURE; it has been superseded by the YES / NO / NOT VISIBLE rule (YES only if p_good ≥ 0.6) under Sim vs real domain gap.
4. Expected accuracy and use. Expect about 80% per hand from the ego view. That is useful as a check, but not a safety-grade signal. Calibrate thresholds, and use bar position only as a coarse servo signal ("stop when middle"), not for the final seat.

Re-running the baselines

python eval.py                                   # all configs, both APIs, local copy
python eval.py --providers openai --configs grip_reference --limit 5
python eval.py --data MicroAGI-Labs/g1d-grip-vision --wrist   # ego+wrist for grip_state
python eval.py --configs grip_reference --providers openai --prompt geometry_3way --domain sim
python eval.py --configs route_clear --providers openai --clear-min 0.8 --min-visible 0.9

• --prompt: selects the OpenAI grip_reference prompt.

  • phase (default): phase-aware wording, works for all phases.
  • old_2way, geometry_2way or geometry_3way: loaded from prompts/, and run on bar_grip rows only. With the 3-way prompt, label_3way is the truth.

• --domain real|sim|all: filters the rows.

• Verdicts: follow the YES / NO / NOT VISIBLE rule above.

• classifier.dev: always uses its 2-image GOOD + test comparison.

• route_clear: uses the same prompt and rule as look route-clear (promptlab/src/tools/look/look.ts, ROUTE_INTRO / ROUTE_Q). The prompt is one line of intro, then the overlay image, then one choice question: CLEAR / OBSTACLE / AREA NOT VISIBLE.

  • Coverage gate: AREA NOT VISIBLE without a model call when visible_frac < --min-visible (default 0.9).
  • CLEAR only if p(CLEAR) ≥ --clear-min (default 0.8, the provisional look value) and p(CLEAR) ≥ p(OBSTACLE).
  • AREA NOT VISIBLE if that choice wins; OBSTACLE otherwise.
  • Scoring: AMBIGUOUS rows are skipped. False CLEAR is reported per domain.
  • Smoke test (OpenAI, run33 o14): p(CLEAR) was 0.63 and 0.67 on the two CLEAR routes and 0.28 and 0.33 on the two OBSTACLE routes. At 0.8 both CLEAR routes come out OBSTACLE, so the ranking is right but the margins are small. The threshold is calibrated on the local set by the look agent.

• Keys: OPENAI_API_KEY is read from ~/.config/astra/openai.env and CLASSIFIER_API_KEY from ~/.config/astra/classifier.env, or from environment variables. They are never printed.

• classifier.dev: called with share_data: false. Its comparison uses GOOD + test only, because of the 2-image limit.

• Output: per-row results go to results/*.jsonl, followed by a summary of accuracy, abstentions and median latency.

• Scoring: uncertain truth rows are not scored.

• Requirements: pip install datasets pillow.

Files

• data/<config>/test-00000-of-00001.parquet
• build_dataset.py: all labels and baseline values, with their provenance. It rebuilds the parquet from ~/g1d-astra/run32/frames.
• scripts/make_servo_shifts.py: the bar_position generator.
• prompts/*.json: the three grip_reference prompts (old, geometry 2-way, geometry 3-way).
• route_clear is built from ~/g1d-astra/datasets/route_clear/labels.jsonl. That folder's scripts/ hold the labels, the renderer and the builder.
• eval.py

License

Released under the Creative Commons Attribution 4.0 International license (CC BY 4.0), (c) 2026 MicroAGI.