Datasets:
SpatiotemporalBench
A benchmark of an agent's task-conditioned spatiotemporal ability, perception and memory both: would this agent, as the onboard brain of a robot doing a real job, know what it needs to know about the space around it, now and over the job's history? Four simulated robots do realistic jobs in three photoreal, changing places. Each job is rendered once along the robot's path (camera, pose and status for the agent; depth for the scorer), with the whole truth kept. The benchmark streams that recording to an agent that keeps its own memory, one frame at a time, asks it the decisions a controller would face during the job and after it (how far could my body go before it touched anything, how close would the person nearest me come, where is that thing, where did I last see it), and checks every answer by code against the truth. Every gold answer is computed by code from the simulator's record of the world; none is written or generated by a model. It measures where things are now and where the things the robot saw earlier are, from seconds to hours before. It does not test change over time (see Limitations).
This card describes the data. The code that runs and scores it (pip install "spatiotemporalbench>=0.11") and the
documentation are at https://github.com/DanMcInerney/SpatiotemporalBench. This dataset is
DanMcInerney/spatiotemporalbench, version 0.11.0.
Summary
A script (the repository's README calls it a shift) is one robot doing one job in one place for 2 to 6 tasks,
rendered once at 640x480 (an RGB JPEG for the agent and a 16-bit depth PNG, private, for the scorer, a keyframe). A
case is a window of a script's tasks, the unit a system is run on: short is 1 task, medium 2 or 3, long 4 to
6. This release ships all three lengths; a script of 2 or 3 tasks has no long window. Tasks are separated by gaps in
which the robot is unobserved and the place changes. Cases are delivered as if they were the whole job: steps are
numbered from 0 and the clock starts fresh, so nothing tells the agent where its window sits in the script. The release
is 16 scripts of each of vacuum/2, helper/1, amr/1 and drone/1 (12 of 2 or 3 tasks and 4 of 4 to 6), 36 cases a
job (16 short, 16 medium and 4 long): 64 scripts and 144 cases. The pictures are those of version 0.7.0; the questions
and their scoring are 0.11.0's.
| Layout | Job | Scripts | Cases (short / medium / long) | Cases asking nothing | Questions | Frames |
|---|---|---|---|---|---|---|
apartment_a |
helper/1 |
16 | 16 / 16 / 4 | 0 | 541 | 3,157 |
apartment_a |
vacuum/2 |
16 | 16 / 16 / 4 | 4 | 711 | 6,460 |
downtown_a |
drone/1 |
16 | 16 / 16 / 4 | 0 | 264 | 2,534 |
warehouse_a |
amr/1 |
16 | 16 / 16 / 4 | 0 | 245 | 4,679 |
| Total | 64 | 64 / 64 / 16 | 4 | 1,761 | 16,830 |
Questions by ability:
| Layout | Job | clearance | distance | memory | relevance |
|---|---|---|---|---|---|
apartment_a |
helper/1 |
191 | 49 | 254 | 47 |
apartment_a |
vacuum/2 |
582 | 0 | 107 | 22 |
downtown_a |
drone/1 |
196 | 0 | 68 | 0 |
warehouse_a |
amr/1 |
105 | 65 | 28 | 47 |
| Total | 1,074 | 114 | 457 | 116 |
Exported by stbench 0.11.0.
The pictures are rendered with Blender Cycles and are in this download. Running and scoring a case needs the stbench
package, which is MIT-licensed code that runs without Blender, a GPU or any further download. Blender is needed only to
build new scripts.
The jobs and the places
Four jobs on three places. A job has an id (vacuum/2), and a result names it.
| Job | Robot | Place | What it does |
|---|---|---|---|
vacuum/2 |
a robot vacuum | apartment_a, a furnished apartment |
cleans one room or two a task, and finishes a room it was sent home from |
helper/1 |
a Stretch-class home helper | apartment_a |
carries a thing from one surface to another or brings one to its spot, and parks again |
amr/1 |
a MiR250-class tote robot | warehouse_a, a warehouse |
docks at the tote shelves and packing tables or runs an order-picking loop, and returns to its charger |
drone/1 |
a Wing-class tether delivery drone | downtown_a, a downtown district seen from the air |
flies the streets to a drop point, inspects it from above, and lowers a package on its tether (an inspection flight does not lower it) |
The apartment is seen by two robots, the vacuum from a camera 0.08 m up and the helper from a head camera at 1.30 m. A
result is reported per layout and per job, and no number pools layouts. The robots' and jobs' numbers are in the code
repository's docs/jobs.md and docs/job-*.md.
Layout
README.md LICENSE CREDITS.md check_report.json release.json
results/<name>.json the reference rows, when the release ships any
scripts/<sid>/ what a robot receives; <sid> is 16 random hex characters
robot.json
sensors/ camera.json pose.jsonl rgb/000000.jpg ...
perception/oracle.jsonl the detections channel's list of what is in view, with 3-D centres
private/ never handed to a system (not secret: the gold is public)
index/<id>.json one entry a script or case
<sid>/ timeline.json visibility.jsonl perception_ids.jsonl render_log.json depth/000000.png ...
<cid>/ case.json questions.jsonl gold.jsonl
The agent has a camera, not a depth sensor. The robot's depth is recorded once, but it is the scorer's: it lives
in private/<sid>/depth/ and nowhere under scripts/, and no agent channel is sent it (the agent judges distance
from the picture). Only the gate channel detections, a perfect detector with no agent behind it, is sent depth,
copied from private/. The depth fields in
robot.json and camera.json (depth, depth_unit, near_m, far_m) describe the scorer's sensor, and no agent
channel delivers its images. perception/oracle.jsonl, with the 3-D centres of what is in view, stays in
scripts/<sid>/ by design: it feeds that diagnostic channel and no agent channel, and the harness never sends it to a
system on rgb_pose.
private/ is named for the code that reads it: the harness never hands these files to a system. They let anyone run,
score and check a case, and recompute every gold from timeline.json and visibility.jsonl without Blender. Every file
and field is described in
docs/format.md of the code
repository. release.json holds the counts above and each case's length and question count.
The protocol and the run commands
A system is a process that speaks the stream protocol. The harness starts it once for a case and sends: start (the
robot's spec and the channel), then for each task a task message (the brief) and one observe of one step for each of
the task's frames, in time order, with an ask right after the frame at a look point; after the last frame, the end
ask and finish. A system's reply to a frame is its request for the next, so it sets the pace. A step is a camera
image, the robot's pose, its own velocity and its status (phase cleaning, task 0, battery_pct 97); there is no depth
image for an agent. Nothing from the future is readable, no step names a thing, a room or an id, and the brief is
composed by the harness at run time (briefs are never files). There are two channels:
| Channel | A system receives | Used for |
|---|---|---|
rgb_pose |
RGB images, pose and status; no depth image | the agents' channel, and the default: perception and memory both |
detections |
depth images (from private/), pose and status, and a perfect list of what is in view |
the gates (below) and the perfect-perception diagnostic; the release has no agent row on it |
The optional rgbd_pose channel of earlier releases is gone: a run that asks for it is refused.
Every question is a decision the robot's brain faces in its job, of one of four kinds. Harm: how far the body could
move before it touched anything, ahead, back, or after turning in place left or right (clear_path), how close a person
came during a task (closest_person), how close the person nearest it would come in the next 5 seconds
(closest_approach), how close the person it saw last, now out of view, would come (approach_mem, new in 0.11.0) and
what on the floor a vacuum's brush could catch (tangle_ahead); who stands within 4 m of the
point below a drone (drop_zone_people) is written, and asked by no job. Help: which heading, turned in place,
would give the body the most room (open_heading), and which way the home helper would set off to reach a thing it saw
before, by the shortest way its body fits through the floor it has seen (way_to, new in 0.11.0); both count in the
headline. Situation: where the nearest visible point of a thing in view is, and where the same point of a thing seen
earlier is, from the camera now (ego_now, ego_mem). Reuse: where on the map it last saw a thing (object_where)
and where the things near its task's path were (task_things; the vacuum's is the list of what its brush could catch,
in the rooms it cleaned). The during questions come at look points, which can be any frame, drawn from the case id and
the plan alone (the robot's decision frames first), a family for each of a point's three slots from a table the job
declares, harm first; the end questions come after the job. Which families a job asks is in the code repository's
docs/questions.md, and check_report.json lists the families that held.
pip install "spatiotemporalbench>=0.11" huggingface_hub
hf download DanMcInerney/spatiotemporalbench --repo-type dataset --revision v0.11.0 --local-dir data
stbench eval all_unknown --data data --out runs/floor
stbench eval claude:sonnet --data data --reasoning medium --workers 3 --out runs/sonnet
stbench eval compare runs/floor runs/sonnet
stbench eval runs a system over the compiled cases that ask a question, resumable and in parallel, and writes one
results.json with one aggregate per layout. SYSTEM is a scripted baseline, FILE.py:Class (your own
agent, in the Docker sandbox, or with --local as a plain process stamped sandbox: none and not a verified score) or
claude:<model> or codex:<model>, the reference agent on a Claude Code or a Codex (ChatGPT) login, on the login's
quota. Add --select job=drone/1 or --select length=short to run part of the release, and --max-usd TOTAL --case-usd X
caps what a paid system may spend. Run one case with stbench run SYSTEM data/private/<cid>. The code repository's
docs/eval.md, docs/agent.md, docs/claude.md and docs/codex.md have the options.
Scoring and the gates
Each question has a gold computed from the timeline and the visibility log, with the frames it is read from named; a
thing the robot never saw, and space it never looked at, is unknown. An answer earns a credit s in [0, 1], the sum of
four quarters: the right direction (the side, the order, blocked or clear), the right thing (whole within twice what the
job needs and falling to nothing at four times), the right amount (whole within what the job needs and falling to
nothing at twice) and precision (whole only within one pixel of the camera at the geometry the gold rests on, falling to
nothing at what the job needs). The credit falls smoothly between those points, so no answer coarser than a pixel earns
the whole. The need is the job's own while the distance judged is within ten of it, and a tenth of that distance beyond
it, the same for every robot (0.11.0): a door 5 m away answered 4 m scores 0, as good as unknown, on every ground
robot, where before the margin was whatever two pixels of the robot's own camera resolved. An answer scores 2s - 1;
unknown scores 0 where an answer exists and 1 where unknown is right; an answer to a question that cannot be known
scores -1. On the harmful side the need is halved: a clearance answered longer than it is, a closest approach answered
wider, a thing or a person placed farther from the camera than it is, a heading without room to move. A list scores per
item (a missed thing costs one and a false place half), a heading by its regret against the best heading's (its right
direction is room to move) and the way to a remembered thing by how much nearer to it a metre of driving along the
heading brings the robot, through the floor seen.
The reported score and catastrophes. 2s - 1 is the gate score: every validity check reads it, and the
score_gate of each result row holds it. The score the headline and the reports read, the row's score, is the same
except for a catastrophe: an answer whose action would end in harm, by a harmful error larger than the job's clearance
(or twice what one pixel resolves there, if more), scores minus 2 if the robot would go into something it had seen (a
corridor said longer than it is) and minus 3 if it would go into a person or onto a hazard of its own kind (a person
said to be clear who came inside the body, or a cord the brush could catch left out of a list), whatever credit it
earned. unknown is never one. Each gold row records the age of its evidence (age_s, age_band: now, recent,
task or earlier), and the reports give the score by band and the catastrophe rate, the share of the harm answers
that are catastrophes. The code repository's docs/question-design.md has the reasoning.
The abilities. Each question belongs to one ability, the thing a controller would ask itself, and every ability is asked from the camera alone. The scorer knows six; the release asks four, and no question about change over time or prediction:
| Ability | A controller asks itself | Column | Asked in this release |
|---|---|---|---|
| distance | where is that thing from me, now? | now |
helper, AMR |
| memory | where, as I last saw it, is that thing from where I am? which way do I set off to reach it? | memory |
all four jobs |
| relevance | what stood within a stated distance of the way I drove, or what could my brush catch in the rooms I cleaned? | memory |
helper, AMR, vacuum |
| clearance | how far could my body go, which way gives it the most room, how close did a person come or would the person nearest me come, what could my brush catch? | now or memory, by what answers it |
all four jobs |
| change | was it where it was on my first pass? | memory |
no job |
| prediction | where will that mover be in a moment? | a diagnostic, in no mean | not built |
The headline is the mean of the now and memory columns (a question is now when the latest frame alone gives
its gold), so perception and memory count equally whatever their question counts, and inside each column its cells, an
ability in that column, are averaged by their weights, each pooled over its own questions. Clearance has a cell in each
column. A cell with 20 questions or more on a job in the dataset weighs 1, so such cells count equally however many
questions each holds above that; a cell with fewer weighs n / 20 of a full cell, where 0.10.0 left it out of the
headline, and a column weighs the largest weight of its cells. A score of a subset or of fresh data takes the cells of
the release's own dev root. If a job has no question in one column, its headline is the other column alone. The mean of
the cells that count, by their weights, and the pooled mean (every question equal) are published beside the headline.
The 95% interval is a bootstrap over scripts. The result is reported per
layout, with its break-down by job, family, length, kind (harm, help, situation, reuse), age of the evidence and
task-criticality, and the agent's cost.
Tolerances
Credit is set by what the job needs to act on an answer, and the numbers are the job's own (JobSpec.clearance and
reacquire, JobSpec.match_m), each with a source in the code repository's docs/questions.md. They are on the gold
row of every question, read from no gold, and the reference agent's system prompt states them in metres and centimetres.
- Where a thing is from the camera (
ego_now,ego_mem), how far the body could move (clear_path), how close a person came or would come (closest_person,closest_approach,approach_mem) and a heading (open_heading) are credited against the job's clearance C, the margin the robot keeps beside its path. A thing's point is the nearest visible point of its outline on the floor. - The way to a remembered thing (
way_to) is credited on the progress of one re-find radius R of driving along the heading, against the best heading's, on the route's own need: C widened to twice the field's 0.1 m cell, so 0.2 m on the helper (C 0.15 m, R 1 m; a tenth of R is under both). A heading with less room than the body needs, or into floor never seen, scores as a wrong answer. - A place in the map (
object_where) is credited against the re-find radius R, within which the robot driving back finds the thing again, to the middle of the thing. For a thing longer than 0.5 m the resolution grows by the thing's half-length beyond 0.25 m, but only when its top was above the camera every time the robot saw it clearly there (the camera saw its sides, not its middle). The direction quarter of a place is being within R, and no more. - A list of places (
task_things,tangle_ahead) is credited per thing against its matching radius, a listed place matching a thing within four matching radii. Each item is a place: it earns its direction quarter within the matching radius of the thing and nowhere else (0.11.0). Where there was nothing to list, the empty list is the one thing, and each false place dilutes it: its credit is 1 over 1 plus half the false places. A place inside a don't-care circle counts neither way.
Within ten of itself the need is absolute. Beyond that it widens to a tenth of the distance judged (0.11.0): a number's gold value, an offset's range from the camera, a heading's best run, and never finer than two pixels of the camera at the gold. A place and a list item keep R and the matching radius at any range.
| Job | Clearance C (m) | Re-find radius R (m) | List matching radius (m) |
|---|---|---|---|
vacuum/2 |
0.10 | 1 | 0.5 (tangle_ahead, task_things) |
helper/1 |
0.15 | 1 | 0.5 |
amr/1 |
0.45 | 1 | 1 |
drone/1 |
2.4 | 2 | none: it asks no list |
A question family is in this release only if shortcuts cannot answer it. check_report.json is the report of stbench check over this release: scripted systems (a perfect memory of what was seen, a memory built from the detections, the
current view alone, the robot's own path log, priors learned from other cases, another case's stream, the other
questions' wording, a form adversary, and all-unknown) run every case on the detections channel, and the gates
(ceiling, knowable, memory_needed, shortcuts, separation, and time_needed on a family about change over
time) are read per layout, job and family, with the balance rule. An export is made only when the evidence reading
passes (each shortcut gate on the evidence of a gain over all_unknown) and no instrument is broken; the report also
holds the stricter reading on the 95% intervals. The map reader, which answers each corridor and heading with the public
map's raycast, is an internal design diagnostic of the two families that ask fixed structure (clear_path,
open_heading): the check reports it, it is not a gate, and no result table here carries it.
stbench check --data data --verdict evidence --workers 8 --out check.json
A released dataset (one with a release.json) keeps its own report unless --out is given.
One public split
There is one split, and all of it is public, gold included: there is no held-out set. A result on it can be overfit, and
it says nothing about a layout this dataset does not hold. The gold is in this download next to the agent you run: a
--local agent runs with your permissions and can read private/, and the Docker sandbox refuses only the truth-file
names in the agent's folder, so neither rules out an agent that carries the public gold in its own code. A result is only
as honest as the system that made it: publish the agent's code with a result and its sandbox field. Do not recompile
the questions: question ids are random per compile, so a recompile orphans every earlier result.
Reference results
These are the reference rows of 0.11.0, run on 0.11.0's questions and prompt and scored by 0.11.0's scorer. The reference
models are Claude models: claude:haiku, claude:sonnet and claude:opus, each at medium effort, once. 0.10.0's rows
were Codex models; they are in the code repository's docs/history/report-0.10.0.md.
| Layout | System | Headline (95% interval) | now |
memory |
Own path | Cases scored | Channel | Arm |
|---|---|---|---|---|---|---|---|---|
apartment_a |
all_unknown |
+0.034 [+0.019, +0.048] | +0.000 [+0.000, +0.000] over 41 | +0.067 [+0.037, +0.097] over 215 | - | 20 | rgb_pose | correct brief, during on |
apartment_a |
claude:haiku (medium) |
+0.152 [+0.076, +0.250] | +0.120 [+0.012, +0.276] over 41 | +0.184 [+0.102, +0.275] over 215 | - | 20 | rgb_pose | correct brief, during on |
apartment_a |
claude:sonnet (medium) |
+0.286 [+0.159, +0.404] | +0.254 [+0.055, +0.435] over 41 | +0.317 [+0.210, +0.407] over 215 | - | 20 | rgb_pose | correct brief, during on |
apartment_a |
claude:opus (medium) |
+0.567 [+0.518, +0.642] | +0.589 [+0.521, +0.705] over 41 | +0.544 [+0.430, +0.663] over 215 | - | 20 | rgb_pose | correct brief, during on |
downtown_a |
all_unknown |
+0.132 [+0.078, +0.219] | +0.000 [+0.000, +0.000] over 22 | +0.263 [+0.156, +0.438] over 46 | - | 11 | rgb_pose | correct brief, during on |
downtown_a |
claude:haiku (medium) |
+0.185 [+0.019, +0.325] | +0.109 [-0.079, +0.318] over 22 | +0.261 [+0.008, +0.467] over 46 | - | 11 | rgb_pose | correct brief, during on |
downtown_a |
claude:sonnet (medium) |
+0.366 [+0.213, +0.505] | +0.380 [+0.201, +0.586] over 22 | +0.351 [+0.111, +0.534] over 46 | - | 11 | rgb_pose | correct brief, during on |
downtown_a |
claude:opus (medium) |
+0.614 [+0.517, +0.717] | +0.596 [+0.463, +0.788] over 22 | +0.632 [+0.506, +0.781] over 46 | - | 11 | rgb_pose | correct brief, during on |
warehouse_a |
all_unknown |
+0.056 [+0.000, +0.125] | +0.000 [+0.000, +0.000] over 24 | +0.111 [+0.000, +0.250] over 40 | - | 11 | rgb_pose | correct brief, during on |
warehouse_a |
claude:haiku (medium) |
+0.273 [+0.112, +0.440] | +0.420 [+0.235, +0.593] over 24 | +0.127 [-0.062, +0.325] over 40 | - | 11 | rgb_pose | correct brief, during on |
warehouse_a |
claude:sonnet (medium) |
+0.307 [+0.077, +0.499] | +0.360 [+0.028, +0.652] over 24 | +0.254 [-0.008, +0.486] over 40 | - | 11 | rgb_pose | correct brief, during on |
warehouse_a |
claude:opus (medium) |
+0.419 [+0.188, +0.638] | +0.501 [+0.276, +0.699] over 24 | +0.338 [-0.002, +0.686] over 40 | - | 11 | rgb_pose | correct brief, during on |
The reference rows use the camera channel, the correct brief and the during questions, with the floor all_unknown. They
cover 42 of the 124 short and medium cases that ask a question (20 apartment cases, 11 warehouse, 11 downtown), the same
42 for every system and the same as 0.10.0's rows, chosen then by the order the runs took them and not by any outcome.
Rows on every case are left for a later revision.
Coverage: all_unknown: 42 of 42 cases; claude:haiku (medium): 42 of 42 cases; claude:sonnet (medium): 42 of 42 cases; claude:opus (medium): 42 of 42 cases.
Compare rows only within a place and on the same cases. The code repository's docs/report.md has the details.
The scripted systems run on both channels. The reference agent reads the camera images on rgb_pose; it can read the
detections channel as text (the arm that measures what the pixels cost, in the code repository's docs/codex.md), but
the release ships no agent row on it.
Licence and credits
This dataset is released under CC BY 4.0. Some of the 3D objects are third-party assets licensed CC BY or
CC0; their attributions are in CREDITS.md. The code is MIT, and render/, which runs inside Blender, is
GPL-3.0-or-later: the frames and files made from it are part of this CC BY 4.0 dataset.
Citation
@misc{spatiotemporalbench2026,
title = {SpatiotemporalBench: spatio-temporal memory of a world perceived through a robot's sensors},
author = {{The SpatiotemporalBench authors}},
year = {2026},
howpublished = {\url{https://github.com/DanMcInerney/SpatiotemporalBench}}
}
Limitations
- Synthetic renders of three fixed layouts, one layout a place (an apartment, a warehouse and a downtown district). Nothing here says how a system fares on real footage or on a place this dataset does not hold.
- The gold is public and there is no held-out set (above): this is a development-style benchmark of these places, not a leaderboard of unseen layouts.
- Every answer comes from the robot's own camera frames, so perception is in every score. The
nowcolumn scores perception apart from memory, but a wrong answer to amemoryquestion may still be a view the agent never took in, not something it forgot; thedetectionschannel is the perfect-perception reference. - There is no agent row on perfect perception. The scripted systems on the
detectionschannel are the only perfect-perception reference in the release, so an agent's perception loss and memory loss are not separated. - The swapped brief of 0.4.x is retired: a job's subgoal says the true task in every frame, so a swapped assignment would contradict it. Task conditioning, the correct brief against the neutral one (which withholds the task and its subgoal), was not read for this release.
- The leak check was not rerun at full size for this release. Whether asking during the job changes the end answers was
last read at full size on 0.9.0's questions, with
gpt-6.1-sol(stbench eval --arms during=on,off): d = +0.043, interval [-0.030, +0.118], inconclusive, with the vacuum's own reading (+0.178) above the margin. 0.10.0 asks one and a half to five times as many questions during the job, so that reading does not carry over, and a leak is not excluded. A subset reading on 0.11.0's compile (claude:sonnet, on 15 dev cases with an end question) gives d +0.123 [-0.018, +0.347] over 33 pairs of 9 scripts: too thin to read. The report reads the answerable pairs for its verdict and the pairs whose right answer isunknownas an abstention shift, apart. open_headingcounts since 0.11.0, with a credit that is room to move on the one need rule; through 0.10.0 its credit was a cliff (a heading a few degrees off the best opening scored -0.4 to -1) and it counted in no mean. The rows' 42 cases hold few of its questions. Only the apartment asks it.way_tois the helper's alone and is thin: 30 questions over the helper's 36 cases. Its seen-floor route is a field over 0.1 m cells, so a gap narrower than about 0.5 m is closed, and every answerable question on the dev root asks for a turn of at least 30 degrees.- The structure questions (
clear_path,open_heading) are asked of public maps. A system that holds a place's layout can answer them without the sensors. The map reader that does so is an internal design diagnostic ofstbench checkand appears in no result table. - Some wrong answers to an
unknownquestion land on a same-coloured thing seen only in glimpses too small to show what it is. The prompt now says that a question may name a thing never seen or not there, and a screen drops anunknownquestion whose window glimpsed a look-alike in the asked colour; no row was run without the sentence, so its effect alone is not measured, and each run'sresults.mdcarries the abstention report (recall, precision, andunknownon answerable questions). - A cell with fewer than 20 questions on a job weighs
n / 20of a full cell. On this release's compile no cell is thin: the least, the AMR's clearancenowand the vacuum's relevance cell, hold 22 questions each. - Change over time is not tested. No question asks what moved, appeared or went since an earlier pass, or where a moving
person is going. The world changes only between tasks, so the short cases hold no change; in the medium cases the
robot sees both sides of only 11 to 28 of the 90 to 165 changes a job's 16 medium cases hold, whether a thing moved is
largely given by its kind, and balancing that leaves a fair change question 4 questions in the whole release. The fix
is new data (scripts that revisit places after the world changes, changes drawn per thing by a coin rather than by
kind, more people walking), which needs new renders, so it is left for a later version. The code repository's
docs/report.mdhas the measurement. - Memory is tested at 1 to 3 tasks, not full shifts. The reference rows cover 42 short and medium cases, minutes of driving, and the reference agent answers from its own context. The 16 long cases (4 to 6 tasks) have no reference row, and real shifts last hours.
- Each job has 16 scripts, and the cases cut from one script are not independent, so the intervals bootstrap over scripts. Compare systems within a layout and job, on the same cases.
- The reference rows are dev rows. They are scored on the scripts the questions and screens were refined on, and no fresh scripts were rendered to confirm them. Every repair made there fixed a broken instrument and applies to every job, but it was made on this data.
- A question family that failed its gates was dropped from its job rather than re-tuned, so jobs differ in the families
they ask: the helper asks no
person_memfor that reason, and the vacuum'stask_thingswas dropped in 0.9.0 and returns in 0.11.0 as the list of what its brush could catch (about 0.6 questions a case). Thecheck_report.jsonof this release is the record of what each job asks and what held. - The apartment's floor texture has a cable-like mark that a model twice took for a cable bundle in an earlier pilot; removing it needs a re-render.
- The gates test the shortcuts we thought of. A system that finds another is outside what they exclude.
- Downloads last month
- -