How Tasks Work
Task lifecycle, slot mechanics, and the data journey from completion to training.
Every task on Arctivar Hub is a data bounty. When you complete a task, you produce a trajectory — a complete recording of how the robot was controlled, what happened in the scene, and whether it succeeded.
The Task Lifecycle
Every task advances along a single path: Pre-training → Training → Post-training. Each entry in the Hub carries a matching three-stage indicator showing where the task stands.
Pre-training
The task collects human demonstrations. Contributors teleoperate the robot to complete the task from scratch; each run adds one demonstration to the task's dataset.
Training
The task's demonstration slots are filled and a policy is being trained on the collected data. The task is visible but not accepting new runs.
Post-training
The trained policy attempts the task while contributors supervise and correct it. Each run adds one correction record — on-policy data that trains the next iteration of the policy.
A task whose stages are all complete shows as Ended in the catalog. The two collection stages produce the platform's two complementary datasets: a diverse demonstration dataset for pre-training, and a correction dataset for post-training.
Task Structure
Each task is defined by:
| Field | Description |
|---|---|
| Name | What to do, plus the robot embodiment (e.g., "Pick up the Plate - Mobile Bimanual") |
| Scenario | The canonical scene it belongs to — kitchen, home, office, workshop, bathroom, play, or general — each with its own icon |
| Skills | The manipulation skills involved: Pick, Place, Stack, Rotate, Transfer, Arrange, Insert, Separate, Reach |
| Difficulty | Beginner, Easy, Medium, Hard, or Expert |
| Lifecycle stage | Pre — Training — Post indicator |
| Slots | How many runs the current stage still accepts |
| Steps | The ordered sub-goals to complete, shown in the task interface |
Tasks are created through the Task Generation Engine, which uses LLM-driven generation to produce diverse manipulation scenarios — from simple pick-and-place to multi-stage sequences involving articulated objects like drawers and cabinet doors. Long-horizon tasks of three or more stages are supported, with state checkpointing so a long run can be recorded in segments and reproduced reliably.
Slots: Counting Data, Not Users
Slots determine how many runs the current stage needs. When all slots are filled, the stage ends and the task moves forward.
This design optimizes for data throughput. A skilled contributor who produces consistently high-quality trajectories is just as valuable as many contributors producing fewer.
Repeatable Completion
You can complete the same task up to 5 times. Each attempt produces an independent data entry with its own completion time and quality score, and every entry that passes evaluation enters the training pool on its own merits.
For Points, though, the entries are not additive. What a task is worth to you is the average score across your completions of it — not your best one. Complete Task 001 in 2m30s for a modest score, retry and finish in 1m26s for a high one, and what counts is the average of the two, not the better of them.
Campaigns & Alliance Tasks
Beyond the standard catalog, the Hub features partner collaborations:
Campaigns. Limited-time collaborations with ecosystem partners, featured in a banner on the Hub homepage — live campaigns are open now, with upcoming ones previewed alongside.
Alliance tasks. The Alliance section hosts tasks built jointly with partners. Every Alliance task awards Arctivar Points plus a partner reward for qualifying contributions. The current Alliance is a dedicated Arctivar subnet on the BitRobot Network: worldwide participants complete simulation tasks on the subnet, and trajectories are scored and verified on-chain. Alliance tasks are pre-training tasks and work exactly like the ones in the Hub; only the reward program and verification chain differ. Note that Alliance contributions are verified on the partner's chain (Solana, for the BitRobot subnet) rather than Base.
What Happens to Your Data
After you complete a run, it enters the production pipeline:
Upload
The client packages your run (task metadata + scene configuration + full trajectory recording) and uploads it to the backend via HTTPS.
Verification by Replay
Every submitted trajectory is replayed in simulation and checked for physical consistency, alongside schema and sanity checks. Invalid submissions never reach training — and well-formed contributions are not diluted.
Scoring
Automated evaluation — rule-based success checking plus VLM-based motion quality assessment — assigns a quality score. For post-training runs, the score also reflects takeover time: the less intervention a completed run needed, the higher it scores. Evaluation is fully algorithmic — no other contributor grades your run.
Signing
From your Portfolio, you sign accepted runs on-chain. Each signed run is recorded on Base with a unique Data ID, bound to its task ID and your contributor ID — together a verifiable provenance trail. Signing is also what admits a run to the Epoch's Points statistics; an unsigned run earns nothing until you sign it. See Sign & Verify.
Into the Loop
Demonstrations that meet quality thresholds are cleaned, replayed in IsaacSim with domain randomization, and fed into policy pre-training. Corrections are aggregated into the correction dataset and used to post-train the task's policy — whose next iteration comes back to the Hub for another round.
Next: Pre-training Tasks →