Human Data Project Framework
Scaler AI Labs · internal

Human Data Project Framework

Frontier labs buy human data to find where their models fail and to fix it. Every such project, ours or anyone's, fits on this one map.

A project is the set of answers to eight questions. Answer them in order; each answer narrows the next.

1
Whose work is it?
Industry, the specific job, how senior the expert must be, which country and language.
Tax preparerPhysicianSoftware engineerHelpdesk technicianCAD drafterRegulatory writerConsumer at homeUS · India · EU · global
2
What does one task look like?
What a finished task produces, how long it takes, and whether it is even solvable as written.
A verifiable answerA document, model, deck, drawing or code changeA changed systemA finished conversationMinutes · hours · daysSome tasks should end in a question, a pause or a refusal
3
Which failure are we isolating?
Pick one primary; it decides everything below. Eighteen modes on the next tab.
Wrong expert answerMisses facts across sourcesLoses the threadMis-uses toolsDoesn't ask / pause / refuse / hand offGames the graderManipulatedUnsafeMakes things up
4
What do experts hand over?
The product. Menu on the last tab.
Hard tasks + reference answersRubricsAutomatic verifiersDemonstrationsGraded model runsPreference pairsEnvironmentsRed-team setsRaw corpora
5
How does the agent act?
Interface and modality.
Chat onlyAPI / MCP toolsTerminalBrowserDesktop or mobile computer useText · vision · voice · code · 3D geometry
6
Where does it run?
What it starts with, whether it can change anything, whether things break mid-task, who else is in the room.
Files onlyContainerMock apps with real actionsReal SaaS sandboxFull OS or phoneSimulated customer or colleagueFaults injected on purpose
7
How is it graded?
Follows the task shape: changed system → automatic check; document → rubric or expert comparison; conversation → end state plus policy; demonstration → step by step.
End-state checkTestsExpert rubricLLM judge calibrated by expertsBlind comparison vs the expert's own workPass rate · pass^k · win rate · attack success
8
What does the lab do with it?
Measure, train, or protect. This sets the acceptance bar, the delivery unit and the price.
Held-out evalSupervised demonstrationsRL environmentPreference / reward dataSafety and red-teamJudge calibrationPretraining corpus

Using it in five steps

  1. Write the failure in one sentence. "Models fail at ___ when ___ because ___." If you can't, run three frontier models on ten sample tasks first and read what went wrong.
  2. Pick one primary failure mode. It decides the task mix (question 2), the environment (6) and the grading (7).
  3. Pick the product and check it matches. Changed-system tasks need an automatic verifier; documents need a rubric or an expert comparison; demonstrations need step-level grading.
  4. Choose the smallest environment that shows the failure. Files ship in weeks; stateful worlds take months and an engineering team.
  5. Prove it is hard, then price it. Run frontier models on a sample; keep tasks where they pass 20 to 50% of the time. Then experts, volume, hours per task, QC, data rights.

Examples on the map

Well-known benchmarks from across the industry, each placed on the eight questions.

GDPval

OpenAI · 2025
Who
44 occupations, 9 US sectors, ~14 yrs experience
Failure
Expert-quality deliverables
Product
1,320 tasks + the expert's own output
Runs in
Chat with reference files
Graded
Experts compare blind, pairwise

HealthBench

OpenAI · 2025
Who
262 physicians across 60 countries
Failure
Wrong or unsafe medical answers in conversation
Product
5,000 conversations + 48,000 rubric criteria
Runs in
Chat only
Graded
Physician-written rubrics, model-applied

Humanity's Last Exam

CAIS / Scale AI · 2025
Who
~1,000 subject experts, 100+ fields
Failure
Wrong expert answer at the frontier of knowledge
Product
~2,500 model-stumping questions with verifiable answers
Runs in
Chat only
Graded
Exact match

SWE-bench Verified

OpenAI / Princeton · 2024
Who
Software engineers
Failure
Fixing real issues in real repos
Product
500 human-validated GitHub issues
Runs in
Container with the repo
Graded
Hidden tests

OSWorld-Verified

XLANG Lab · 2024, revised 2025
Who
General computer user
Failure
Operating a real desktop; flagging impossible tasks
Product
369 tasks + automatic checkers
Runs in
Full Ubuntu VM
Graded
Scripts check final state; top agents now above 85%

τ²-bench

Sierra · 2025
Who
Airline, retail, telecom support agent
Failure
Following policy under customer pressure
Product
Policy + tools + simulated customer who can also act
Runs in
Mock booking system
Graded
Database end state; pass^k

ClawSafety

Academic · 2026
Who
Professionals running a personal agent with full machine access
Failure
Manipulated by injected instructions
Product
120 adversarial scenarios via skill files, emails, web pages
Runs in
Sandboxed workspaces
Graded
Attack success rate: 40 to 75% across frontier models

Vending-Bench

Andon Labs · 2025
Who
Small-business operator
Failure
Losing coherence over months of simulated time
Product
A simulated business with suppliers and customers
Runs in
Mock email, inventory, bank
Graded
Final net worth

Same map, different answers. New domains (life sciences, CAD, mechanical engineering) and new modalities (voice, code, 3D) change the environment, the verifier and the expert pool; they do not need a new framework.

The eight questions as a production line. Walk a request left to right; every stage has a fixed set of choices, so the output is a fully specified project.

Failure sentence
→
1Who
→
2Task
→
3Failure mode
→
4Product
→
5Access
→
6Environment
→
7Grading
→
8Use & ops
→
Project spec

Two loops: calibration at stage 7 sends tasks back to stage 2 when frontier models pass too often or too rarely; the one-sentence failure statement is rewritten whenever stage 3 can't name a single primary mode.

Start: the failure sentence

"Frontier models fail at ___ when ___ because ___." If it can't be written, run three frontier models on ten sample tasks and read the failures first.

Whose work is it?

Pick the sector, then the specialty, then one job role. One role = one expert pipeline.

Domain 20+; examples
Finance & accountingLegalLife sciences & pharmaHealthcare clinical opsIT services & helpdeskSoftware engineeringEngineering & CADMechanical & manufacturingConsulting & strategySales & marketingHR & people opsOperations & supply chainCustomer supportGovernmentEducationReal estate & insuranceMedia & creativeResearch / STEMPersonal / consumer
Sub-domain open; examples
Finance → tax prep · entity tax · audit · FP&A · M&A diligence · treasuryLegal → contracts · litigation · compliance · IPLife sciences → regulatory · clinical ops · bioinformatics · med-chem · pharmacovigilanceMechanical → design · FEA · DFM · qualityIT → helpdesk · sysadmin · security · MSP
Persona open; examples
Tax preparerAuditorContracts associateRegulatory writerClinical research associateBioinformaticianCAD drafterDesign engineerFEA analystL2 technicianSREManagement consultantSupport agentMedical coderConsumer at home
Expert tier 4
Consumer / general userPractitioner (2–5 yrs)Senior practitioner (5+ yrs, verifiable)Credentialed specialist (CPA/CA, lawyer, physician, PE, PhD)
Geography 5
USIndiaUK / EUGlobal (English)Other / multi-country

What does one task look like?

Decide the shape, the length, the output, and the share of tasks that should end in a question, a pause or a refusal.

Task shape 7
Verifiable answerArtifact productionState changeInvestigation / diagnosisDecision / recommendationService conversationOpen-ended objective
Horizon 5
Single stepShort (2–10 steps)Medium (10–50)Long (50+)Multi-session (days)
Specification 5
Fully specifiedUnderspecified → should askImpossible → should flagPolicy-trapped → should pause or declineMixed at a hidden ratio
Output artifact 10
Text / documentSpreadsheet / modelSlidesStructured record (JSON, ticket, DB row)Code / repoCAD model / drawingAudioImage / videoSystem state onlyTranscript
Difficulty gate 4; measured, not asserted
<20% frontier pass20–50% (usual target)50–80%Uncalibrated

Which failure are we isolating?

Exactly one primary, up to three secondary. The primary dictates stages 2, 6 and 7.

Capability 8
Wrong expert answerMisses facts across sourcesLoses the threadPlans badly on open-ended workMis-uses toolsCan't recoverUnreliable on repeatFails off the US / English default
Judgment 5
Doesn't askDoesn't pauseDoesn't say "impossible"Doesn't hand offBreaks policy
Integrity & safety 5
Games the graderBends the rules for someoneManipulatedUnsafeMakes things up

What do experts hand over?

One primary product, plus whatever must ship with it (a rubric with the tasks, seed data with the environment).

Product 9 blocks
Hard tasks + referenceRubricsVerifiersEnvironmentsDemonstrationsGraded runsRed-team setsCorporaProduct-level panel evals
Sub-types where it matters
Demonstrations → golden · error-recovery · GUI recordingsGraded runs → step-level · pairwise · absolute scoreTasks → stumping prompts · with expert deliverable · with simulated userEnvironments → single app · coupled multi-app · with user simulator · with injected faultsCorpora → workbooks · documents · app data · voice · video · CAD

How does the agent act?

Match the lab's product surface. Computer use and coupled apps roughly double environment cost; choose them only when the failure needs them.

Interface 8; multi-select
Chat onlyAPI / function callingMCPCLI / terminalBrowserDesktop computer useMobile computer useFile system
Cross-app coupling 3
None (single app)Context carry-over (data moves, apps independent)Coupled state (one app changes another)
Modality 6
TextText + visionVoice / audioCode3D / CAD geometryMultimodal

Where does it run?

The smallest world in which the failure is visible and gradable. Statefulness is the cost driver.

Environment type 8
None (prompt only)File bundleSandbox containerMock stateful servicesReal SaaS sandboxFull OS VM / phoneSimulated user or counterpartyHybrid
Statefulness 4
StatelessStateful, read-onlyStateful, writeDynamic: faults injected mid-task
Input realism 4
Production-sourced (anonymised)Expert-synthesised from real workHybridSynthetic
Who else is in the room 5
Nobody (single turn)Simulated userDual control (user also acts)Other agentsLive human
Setup effort 3
Low: files, weeksMedium: container or mock service, 1–2 monthsHigh: coupled world, VM, licences, months + engineering

How is it graded?

Method follows task shape. Reference standard is the quality ceiling of the whole dataset. Calibrate on frontier models before shipping.

Method 9
Automatic end-state checkUnit / hidden testsSchema / field diffHuman rubricLLM judge, expert-calibratedBlind pairwise vs expert's workStep-level trajectory gradingCheckpoint partial creditHybrid
Reference standard 5
Practitioner-reviewed deliverableExpert consensusGround-truth stateRubric onlyNone (open-ended)
Headline metric 8
Pass ratepass^k (reliability)Accuracy / precision / recallWin / tie rate vs expertRubric scoreAttack success rateCost & timeNet value
Calibration loop to stage 2
Pass@3 on three frontier models per taskSame rollouts reused as reviewer materialVerifier tested against deliberately wrong runs

What does the lab do with it, and how do we staff it?

Use sets the acceptance bar and the delivery unit; the delivery unit sets the pricing unit.

Lab use 8
Held-out evalSupervised fine-tuningRL environmentPreference / reward dataRed-teamJudge calibrationPretraining corpusProduct-level eval
Delivery unit 7
Tasks + reference + rubricTrajectoriesEnvironment packageGraded runsPreference pairsRaw artifactsAudio + transcripts
Sourcing pool 4
US consumer / professional panelIndia expert benchEnterprise partnersMarketplace / freelancers
Ops fields 7
Expert profile & verificationVolumeHours per unit (incl. rework)QC chain (author → auto-QC → reviewer → audit)Infra (hosting, harness, recording, review)IP / PII / consentPricing unit: per task · hour · environment · trajectory · sample · panel run

Output: a project spec

One line per stage, one primary failure mode, a calibrated difficulty band, and a price. If any stage is blank, the project is not ready to quote.

Eighteen ways frontier models fail today. A project isolates one as primary and may measure up to three more on the side.

FailureWhat it looks likeHow it is measuredWhere it shows up todayHuman data that targets it
Capability: the model cannot do the work
Wrong expert answerThe professional content is wrong even when the format looks right.Expert rubric; blind comparison with the expert's own work; exact match where answers are verifiable.GDPval, HealthBench, Humanity's Last Exam, APEX, Harvey LAB (legal), Finance AgentHard tasks with reference answers; credentialed rubrics
Misses facts across sourcesThe answer needs facts from several documents, tabs, apps or emails and the model joins only some of them.Field-by-field diff against a reviewed reference; must-have rubric criteria.Tax-prep and spreadsheet benchmarks (Thrive, GDP.xlsx, SpreadsheetBench 2, GDP.pdf)Realistic document packages with practitioner-reviewed references
Loses the threadPlan, state or memory drifts over many steps, long contexts or multiple sessions.Long-horizon task success; checkpoint partial credit; net value over simulated time.Vending-Bench, TheAgentCompany, JobBench, LOCA-Bench 256K, METR time-horizon studiesMulti-day task environments; demonstrations with state hand-offs
Plans badly on open-ended workResearch, ML engineering or investigation with no fixed recipe: the model stops early, follows one path, never checks.Expert rubric on process and output; reproduction of known results.MLE-bench, PaperBench, WideResearch, DeepPlanning, BrowseComp (now near saturation)Expert-authored open problems with rubrics for the process, not just the answer
Mis-uses toolsWrong tool, wrong arguments, wrong order; clicks the wrong thing; mis-reads a dense screen.End-state check; function-call accuracy.Terminal-Bench 2.0, Toolathlon, MCP Atlas, BFCL v4, AndroidWorld, MobileWorld; OSWorld-Verified is saturating above 85%Environments with verifiers; GUI demonstrations on new surfaces (mobile, CAD, design, spreadsheets)
Can't recoverA tool errors, state goes stale or an earlier step was wrong; the model retries blindly or silently drops the task.Success after injected faults; step-level grading of the recovery.Terminal-Bench repairs; mostly unmeasured elsewhereEnvironments with injected faults; expert recovery demonstrations
Unreliable on repeatPasses once, fails on the next run of the same task.pass^k: must succeed k times in a row.τ²/τ³-bench, Toolathlon-Verified, MCPMarkVerifiers that run many trials cheaply; task sets sized for repeat runs
Fails off the US / English defaultWrong currency, regulation, format or language; brittle on code-switching and local workflows.Same benchmarks, rebuilt for a locale; locale-specific references.Almost every public benchmark is US-centric and English-onlyCountry-specific task sets and experts (GST, local filings, Indian-English voice)
Judgment: the model could do it but decides wrongly
Doesn't askThe task is ambiguous and the right first move is a question; the model guesses.Share of runs that ask before acting; quality of the question; end state after the answer.τ-bench information gathering; otherwise rareUnderspecified tasks with a labelled right question and a simulated user
Doesn't pauseTakes an irreversible, paid or privileged action without seeking approval.Correct stop at a labelled approval boundary; completion without crossing it.Helpdesk evals ("seek approval"); personal-agent product evalsEnvironments with irreversible actions and an approval matrix
Doesn't say "impossible"The task cannot be done as written; the model fakes a completion.Correct abstention on infeasible tasks mixed in at a hidden ratio.OSWorld infeasible subset; WorkArena++Impossible and conflicting tasks with labelled correct behaviour
Doesn't hand offShould transfer to a human specialist (technician, clinician, partner) and package the handoff; instead it pushes on.Correct escalation decision plus quality of the handoff note.Helpdesk evals ("hand to a technician"); ITBenchPractitioner-written escalation criteria; graded handoff notes
Breaks policyIgnores the written SOP, playbook or constraints while finishing the task.Outcome plus rule adherence; forbidden-action count.τ²/τ³-bench, Harvey LAB, EnterpriseOps-GymPolicy documents plus policy-trapped tasks
Integrity and safety: the model does something it shouldn't
Games the graderCollects the reward without doing the work: edits the test, hard-codes the answer, satisfies the rubric's letter.Verifier audits; adversarial runs against the grader; human spot checks.Reported as common across RL environments by every vendor and labHack-resistant verifiers; graded examples of gaming; judge calibration
Bends the rules for someoneCaves to user pressure, colludes with another agent, sandbags, or quietly grabs privileges.Integrity-preserving behaviour in scenarios with an incentive to cheat.Sabotage and sandbagging evals from lab safety teams; few public multi-agent setsScenarios with a counterparty who benefits from a rule bend; labelled correct behaviour
ManipulatedFollows instructions injected through emails, tickets, web pages, tool output or skill files.Attack success rate alongside task utility.AgentDojo; ClawSafety (40 to 75% attack success on frontier models)Red-team suites with realistic placements, paired with benign tasks
UnsafeDestructive actions, data leaks, PII exposure, dangerous advice.Boundary crossings per run; harm-domain rubrics.HealthBench safety axis; agent security benchmarks; Cybench / CyberGym for offensive capabilityEnvironments with destructive actions and sensitive data; harm-boundary labels
Makes things upFabricates facts, records, citations or completions.Evidence checks against the supplied inputs; citation resolution.Legal and life-sciences drafting; tax prep ("do not copy prior-year amounts")Citation-grounded tasks with verifiers; references the model must cite

Public benchmarks crowd the capability rows and the top of the tool-use row is saturating. The judgment and integrity rows are where models fail most visibly in deployment and where the fewest good datasets exist.

What labs are buying in 2026, the building blocks we sell, and the frontier projects worth picking up.

Where the industry is (October 2026)

Evaluation is the new datasetLabelling is cheap. The premium moved to designing hard tasks, environments, verifiers and rubrics.
Every frontier lab buys evals and preference dataAll of the ten largest buy expert evaluation and preference data and code; six also buy agent trajectories or RL environments.
Environments are priced per taskMost RL-environment tasks sell for $200 to $2,000; contracts run six to seven figures a quarter; exclusivity costs four to five times more.
Spend is ~$1B per lab per yearIndustry figure, not audited. One lab is discussing over $1B on environments alone next year.
Multi-vendor by designLabs keep a small in-house data team and split production across vendors; neutrality from Big Tech equity is a buying criterion.
Known pain pointsReward hacking, environments that break when apps change, and the manual effort of defining tasks and grading criteria.

Building blocks

Each block has a natural task shape, grading method and use. If a project's don't line up, it is two projects.

BlockWhat experts hand overGraded byLab uses it for
Hard tasks + referenceTasks calibrated to beat frontier models, with the expert's own answer or deliverableExact match, field diff, rubric, blind comparisonHeld-out evals; preference data
RubricsWeighted, atomic criteria with severity, written after seeing model attemptsExperts, or an LLM judge calibrated by expertsEvals; rubric-as-reward RL; preference data
VerifiersAutomatic checks on end state, tests or structured output, audited against gamingProgrammaticRL environments; repeat-run evals
EnvironmentsMock or sandboxed apps with real actions, seed data, reset, optional simulated users and injected faultsVerifiersRL training; agent evals
DemonstrationsExpert trajectories with rationale, including GUI recordings and recoveries from faultsStep-level reviewSupervised fine-tuning; judge calibration
Graded runsModel trajectories labelled step by step, pairwise or on a scaleExpert agreementReward models; judge calibration
Red-team setsInjections, social engineering and incentive traps placed where real attackers would put themAttack success + utilitySafety evals and training
CorporaReal workbooks, documents, app data, voice, video, CAD files with rights clearedAcceptance criteriaPretraining; seed inputs for all of the above
Product-level panel evalsReal users with seeded data running the agent as shipped, across productsRubric + end stateProduct decisions; permission and scope policy

Frontier projects we can pick up

Universal project types, chosen where public benchmarks are thin or saturating and where labs are spending. Each names the failure it targets and what it takes to build.

Project typeWhat it isWhy nowWhat it takes
Measure
Credentialed professional evalsRubric-graded deliverables and conversations written and graded by licensed or senior professionals: medicine, law, tax, audit, engineering, pharma regulatory.The most common lab ask; GDPval, HealthBench and Harvey LAB set the pattern, and every domain and country beyond the US is still open.Credentialed experts, rubric training, calibration runs, grading interface.
Judgment evals (ask, pause, refuse, hand off)Task sets where the right behaviour is a question, an approval request, an abstention or an escalation, mixed at a hidden ratio with normal tasks.Almost no public coverage; this is where deployed agents fail in front of customers.Practitioners who write approval and escalation policy; environments with irreversible actions; simulated users.
Multi-day work evalsTasks that span sessions and days with state hand-offs, interruptions and memory: a week of an analyst's or coordinator's job.Task horizons that models can complete keep doubling; benchmarks still mostly measure minutes.Stateful environment with persistence; expert demonstrations; checkpoint grading.
Locale-native task setsGDPval-style and tool-use tasks built for India, the EU, the Gulf and other markets: local filings, regulation, currency, language, code-switching.Public benchmarks are US-centric; labs selling globally need the gap measured.In-country senior practitioners; locale-specific reference inputs.
Product-level panel evalsReal users with seeded data run the agent as shipped (model + harness + memory + connectors + approval UX) across competing products.Model benchmarks don't predict product behaviour; labs now evaluate the whole stack.Consented user panel, seeded app data, recording and review ops.
Train
Enterprise workflow gymsStateful mock mail, calendar, tickets, CRM, ledger, ITSM with write actions, seed data, reset and end-state verifiers, in one domain or coupled across apps.Nearly half of new vendor projects are environments; enterprise ops is the largest unsaturated surface.Environment engineers, practitioners for tasks, verifier audits against gaming.
New-surface computer-use demonstrationsExpert GUI trajectories on surfaces beyond the Linux desktop: mobile, CAD, design tools, spreadsheets, EHR, ERP.Desktop benchmarks are saturating above 85%; the next surfaces have no demonstrations.Hosted apps with licences, recording platform, experts who use the tools daily.
Error-recovery dataFaults injected mid-task (expired tokens, stale records, rejected calls, a wrong earlier step) with expert recoveries and step-level grades.Recovery is the main gap between demo and deployment and is almost unmeasured.Fault-injection layer in an environment; practitioners who handle these failures daily.
Hack-resistant verifiers and judge calibrationVerifiers audited against reward hacking, plus expert-graded trajectories that calibrate LLM judges and reward models.Reward hacking is the pain point labs name first; rubric-as-reward training needs trusted graders.Senior experts for grading, adversarial testers, agreement measurement.
Code beyond bug-fixingRepo-level tasks with tests for refactoring, code review, data pipelines, migrations, incident remediation and security.All ten frontier labs buy code; SWE-bench-style fixes are saturating, the adjacent tasks are not.Senior engineers, containerised repos, hidden tests.
Voice agent environmentsPolicy-bound service tasks with a simulated caller over speech, tool calls and end-state verifiers; accents, noise, interruptions, code-switching.Voice agents are shipping; text τ-bench has no voice equivalent at scale.Speech stack, simulated caller, support practitioners, native speakers.
Protect
Agent security suitesInjection and social-engineering cases through emails, tickets, documents, web pages and skill files, paired with benign tasks so utility is measured too.Attack success on frontier models is still 40 to 75% in realistic workspaces.Security practitioners, environments with untrusted content paths.
Integrity scenariosCounterparties with an incentive for the agent to bend a rule: user pressure, multi-agent collusion, sandbagging, privilege grabs; labelled correct behaviour.Lab safety teams run these in-house; very little vendor supply.Multi-agent orchestration, compliance practitioners, safety reviewers.
Safety boundary gymsEnvironments where destructive and data-leaking actions exist and are sometimes the fastest route; tasks completable without crossing the boundary.Personal and enterprise agents now hold real permissions; boundary behaviour is a release gate.Admin and privacy practitioners; action logging in the environment.
Supply
Rights-cleared real artifactsReal workbooks, document packages, app data, voice and video, CAD files, with consent, used as seed inputs for the projects above.Realistic inputs are what make synthesis and grounding failures appear; synthetic inputs don't.Contributor panels, consent and PII process, acceptance QC.

Sources for the industry figures: the 2026 human-data market analyses by Pebblous and Glasp (Epoch AI and SemiAnalysis pricing interviews), the October 2026 agentic leaderboards, and the ClawSafety paper (arXiv 2604.01438). Figures will drift; the structure won't.