Explore opportunities

Author repo-scale coding tasks in Python, Go or Java and adjudicate the model's patch against your own tests.

Grade model-written React on the things tests miss: accessibility, re-render cost and state that should never have been local.

Write scenarios where consensus, clock skew or partial failure breaks the system, and score whether the model reasons or guesses.

Benchmark model-written kernels for occupancy, bank conflicts and numerical drift, then explain why they are slow.

Judge whether model-proposed sharding, checkpointing and data-loading advice would actually survive a multi-node run.

Replay real incident timelines and score whether the model's next action would have helped, done nothing, or made it worse.

Verify model reasoning about COBOL copybooks, JCL and ABAP that no public training corpus covers well.

Score model answers on interrupt safety, DMA coherency and timing budgets where a plausible answer bricks the device.

Grade model query rewrites against real execution plans, isolation semantics and index cost — not against intuition.

Hand the model a packet capture and score whether it finds the retransmit storm or invents a plausible cause.

Turn model-written test suites inside out: do they actually fail when the code is broken?

Read an agent's whole run — every tool call, every retry — and mark the step where it stopped making sense.

Record yourself doing ordinary computer chores, one deliberate click at a time, with a reason typed for each.

Design the scoring function that decides which agent behaviours get reinforced, then find how it will be gamed.

Decide whether the agent clicked the right thing for the right reason, or the right thing by accident.

Write the tool definitions agents are given, including the badly-written ones they have to survive.

Judge whether an agent that ran for three hours was making progress or elaborately standing still.

Choose between two answers that are both fine, and write down the reason that would hold up if someone disagreed.

Score multi-thousand-word answers against a six-dimension rubric without letting one bad paragraph sink the rest.

Find the cases where the automated judge and a careful human diverge — that gap is the deliverable.

Check every citation the model gave you and record which ones support the sentence they are attached to.

Count the constraints in the prompt, check each one, and ignore how good the answer otherwise is.

Write the answer the model should have given — the reference, not a correction of what it produced.

Build chosen/rejected pairs that differ on exactly one thing, so the gradient has nowhere else to go.

Run long conversations designed to break the model's memory, then mark the exact turn it forgot something.

Apply a 60-label taxonomy to short text, and be the person who notices when two labels overlap.

Decide where an entity actually starts and ends, in text where the answer is genuinely contested.

Play a specific person with a specific problem, convincingly enough that the transcript is worth training on.

Judge whether a retrieved passage answers the query or merely shares its vocabulary.

Write the document fifty annotators will read literally, then fix every place they read it differently.

Label the text where positive words carry negative meaning, and say which cue told you.

Pull the right number out of a badly scanned table, and record how you knew which column it was in.

Check whether the model is describing the image in front of it or the image it expected to see.

Write questions about charts that cannot be answered by reading one number off an axis.

Mark the frame where an action begins, and argue for it when a colleague picks a different one.

Transcribe what the writer actually wrote, including the misspelling, and mark what you genuinely cannot read.

Score generated images on prompt fidelity, and separately on the anatomy nobody wants to look at closely.

Correct machine transcripts of speech the machine was never trained to hear, and log why it failed.

Listen to synthetic speech and say precisely what is wrong with it, not just that it sounds off.

Record your own voice reading prompts and talking naturally, in your own accent, deliberately unpolished.

Mark who is speaking and when, especially in the four seconds where three people are talking at once.

Write the Swahili answers the model should give, in Swahili it would not produce by translating from English.

Build first-party Gĩkũyũ text where almost none exists, with tone marked and provenance recorded.

Produce and annotate the mid-sentence language switching that real speakers do and corpora never capture.

Rate Hindi output on whether a Hindi speaker would say it, separately from whether it is grammatical.

Check whether the honorific level matches the relationship, including the times it is too polite.

Fix machine translation into Portuguese and log which errors the engine keeps making.

Write and correct Yorùbá with full diacritics, in a corpus where almost everything online has none.

Author Vietnamese reference answers where the pronoun choice alone encodes who is speaking to whom.

Produce Taglish as it is actually spoken and annotate what triggers each switch mid-clause.

Check the speech level holds for a whole message, because switching mid-paragraph is the tell.

Review German output for invented compounds, Anglicisms and the Sie/du choice the model gets wrong.

Bring machine French to publication standard and classify every edit so the engine's profile is measurable.

Write Bengali reference answers in one variety on purpose, rather than the blend the model produces.

Review Urdu for the orthography and vocabulary that separate it from Hindi in everything but grammar.

Write technical Amharic that mostly does not exist yet, and record the terms you had to settle.

Check the concord agreement chain, which is where model isiZulu falls apart in longer sentences.

Produce written Hausa in Boko script with tone and length marked, plus the switching real speakers use.

Write original Somali across domains the digital corpus simply does not have, with dialect recorded.

Review Thai where the model got the words right and the word boundaries, particles or politeness wrong.

Write Polish reference answers where case government and verbal aspect are chosen, not guessed.

Post-edit Turkish where a single wrong suffix in a seven-suffix chain changes who did what to whom.

Break the model's refusal behaviour on purpose, document the technique, and check whether the patch actually held.

Label the requests that sit exactly on the policy line, where both refusing and answering are defensible.

Judge whether a model's answer would meaningfully help someone who should not be helped, using expertise almost no one has.

Measure how far a model can actually get on an intrusion chain, in a range where it cannot reach anything real.

Decide the cases two trained reviewers could not agree on, and write the rule so the next one is easier.

Grade the differential, not the final answer — most model errors are a correct diagnosis reached by an unsafe route.

Read the study yourself, then judge whether the model's report would be safe to sign.

Write the reference answer for cases where the guideline runs out and the tumour board actually decides.

Judge risk responses on both failure directions: missing the risk, and treating every low mood as an emergency.

Check dosing, interactions and the renal adjustment the model silently left out.

Judge whether a patient could actually follow the instruction, and whether they would still ask the real question.

Annotate what a clinical note actually asserts, including the findings it explicitly rules out.

Check the model's citations against the actual evidence, including whether the trial population matches the patient.

Judge the model's code assignment against the documentation, including the specificity it invented.

Decide whether the criteria were actually met, and whether the model's denial would survive appeal.

Evaluate whether the model's denial-resolution plan would actually get the claim paid.

Annotate the front-desk decisions that look trivial and hold a clinic's day together.

The model reads each clause correctly and loses the obligation the cross-reference three pages later imposes.

Check every citation to the reporter, then check whether the case still says what the model claims it says.

Answers that are correct under GDPR and quietly wrong under the three other regimes the same product operates in.

Claim scope is decided by one word in the preamble, and the model reads the abstract.

Label responsiveness, privilege and issue tags on discovery documents where the hard calls are all partial.

Every plain-language rewrite is a redraft, and a redraft can change what the notice legally does.

The derivation is clean, the model is the wrong one for the payoff, and nothing in the output says so.

A DCF whose arithmetic is perfect and whose terminal growth rate quietly exceeds long-run GDP.

Risk numbers computed correctly under an assumption the scenario was specifically designed to break.

Answers that blend IFRS and US GAAP into a single set of rules that exists in neither.

Label why an alert closes, not just that it closes — the reason is the only part a regulator reads.

Treaty analysis that is right on the article and wrong on which country's domestic law gets there first.

A structure that partitions the problem beautifully and never gets to a number anyone could act on.

Diagnoses that name the bottleneck the data shows and miss the one the plant floor would have told you about.

Explanations that are correct, age-appropriate and give away the answer the student was about to reach.

Items that test whether the student read carefully rather than whether they understood anything.

Accommodations that are legally correct, generically stated, and impossible for a teacher to implement on Tuesday.

Grades that track how well an essay is written rather than whether its argument holds.

Find the step that is asserted rather than proved, and say what would have to be true for it to hold.

Solutions that reach the right number with units that do not survive a dimensional check.

Routes that are textbook-correct on paper and would fail at step three in an actual fume hood.

Protocols with every reagent and no control that would tell you the result meant anything.

The test is applied correctly, the assumption it needs was never checked, and the p-value is reported to three decimals.

Calculations that pass on the load case that was given and were never checked against the one that governs.

Coordination curves that grade correctly at fault current and lose selectivity everywhere else on the curve.

Prose with no bad sentences in it and no reason for anyone to read the second page.

Write the reference scenes where the characters say the wrong thing and mean the right one.

Copy that follows every rule in the brand guide and sounds like a different company each time.

Technically flawless images that solve none of the problem the brief actually set.

Eight bars that work, repeated until the piece ends, with nothing developing in between.

Answers that cite the right article of a code cycle the jurisdiction has not adopted yet.

Diagnostic trees that reach the failed part by replacing the four cheaper ones first.

Reading a fault code as a diagnosis rather than as a symptom, which is how good parts get replaced.

Queries that run, return a number, and answer a slightly different question than the one asked.

Reading a result as a decision when the experiment could never have detected the effect that mattered.

Charts that are technically valid and mislead anyone who reads them at a glance, which is everyone.

Diagnoses that tune the hyperparameters of a model whose training set leaked the label.