LH2 AI Labs
Website:
lh2.fr
Company:
https://www.linkedin.com/company/lh2-ai-labs
Industries: Artificial Intelligence
Job details:
Mandatory requirement: Graduate from a Tier 1 engineering institution such as IIT, BITS, NIT, IIIT, or an equivalent institution.
About LH2 AI Labs
Built by second-time founders who have built and sold companies before, LH2 AI Labs is building the post-training infrastructure for frontier AI models.
We bring private, high-quality institutional datasets and vetted domain experts into frontier AI pipelines across coding, computer use, agentic workflows, medical, audio, company operations, and more.
Frontier models have already learned from much of the public web. The next capability gains will come from high-quality data and environments grounded in real production work: tasks with meaningful state, reliable verification, realistic tools, and reward signals that cannot be easily gamed.
Our vision is to make high-quality post-training data and environments available to frontier models as readily as compute is available today.
About the role
We are looking for a Founding Member of Technical Staff (RL Environments and Evaluation) to build the environments in which advanced AI agents learn and are evaluated.
This is not a role focused only on writing benchmarks or wrapping an existing repository in a Docker container. You will design robust, scalable training and evaluation environments - especially for coding and real-world agent workflows - where agents can interact with tools, make multi-step decisions, alter state, recover from mistakes, and be evaluated fairly.
You will own the difficult questions behind valuable post-training data:
- What makes a task genuinely challenging, realistic, and useful for a frontier lab?
- How do we build deterministic environments that remain difficult without becoming flaky?
- How do we define ground truth and reward long-horizon agent behavior, especially when a simple test suite does not exist?
- How do we prevent models from exploiting a verifier, simulator, reward function, or user model rather than completing the underlying work?
- How do we turn one strong environment into hundreds of diverse, calibrated, contamination-safe training and evaluation variants?
You will work closely with the founders, product, data, and domain-expert teams to decide which capabilities and verticals LH2 AI Labs should build for next.
What you’ll do?
Build robust coding environments
- Convert real engineering work - such as merged pull requests, bug fixes, feature changes, and repository history - into high-quality agent tasks, RL environments, and evaluations.
- Build hermetic, reproducible task environments using Docker, pinned dependencies, deterministic setup scripts, and reliable build tooling.
- Resurrect and stabilize real-world repositories with outdated dependencies, broken lockfiles, inconsistent test suites, and legacy build systems.
- Create fail-to-pass and pass-to-pass test sets that distinguish genuine problem-solving from shallow patching.
- Build sandboxing and execution infrastructure that can support reliable, parallel agent rollouts at scale.
Design verifiers and reward signals
- Design deterministic verifiers, graders, and reward functions for coding and agentic tasks.
- Develop partial-credit systems where appropriate, while keeping reward signals resistant to shortcutting and manipulation.
- Identify and eliminate verifier weaknesses such as editable tests, stdout-based grading loopholes, test leakage, flaky tests, shared state, or exploitable environment behavior.
- Design reward signals for long-horizon tasks where only the final outcome may be directly verifiable.
- Decide when a task should use programmatic state assertions, checkpoint-based evaluation, an LLM judge, or a hybrid approach - and measure judge reliability rather than assuming it.
Create stateful agent environments
- Build coherent simulated worlds for real business and operational workflows: for example, mock Jira instances, seeded CRMs, Slack workspaces with history, internal admin tools, browser applications, and multi-system workflows.
- Define the backend state, reset semantics, action space, observations, tools, and determinism guarantees for each environment.
- Design interfaces and abstractions for environments, including Gym-style step/reset APIs, tool schemas, action-space design, observation truncation, and versioning.
- Build environments where the final state may be correct but the agent’s execution path still matters - for example, an agent resolving a duplicate support ticket while preserving auditability, permissions, customer communication, and operational safeguards.
- Develop simulated users and multi-agent setups that are useful for training without becoming predictable systems an agent can exploit.
Develop post-training and evaluation methodology
- Apply RL methods such as GRPO and PPO to practical environment-design problems: reward shaping, advantage estimation, KL control, credit assignment across long trajectories, rollout stability, and diagnosing training collapse.
- Run post-training and evaluation experiments to validate that our environments produce a real learning signal rather than superficial benchmark gains.
- Develop task-generation and curriculum strategies that scale from one carefully designed environment to hundreds of seeded, diverse, difficulty-calibrated variants.
- Measure difficulty, saturation, variance across seeds, and the distinction between pass@k and pass-to-the-k style metrics where relevant.
- Build held-out evaluation designs that preserve train-test separation at the environment or world level—not merely at the individual-task level.
Mine high-value task data
- Mine repository and PR history at scale to identify engineering work worth turning into tasks.
- Build pipelines for deduplication, secret and PII removal, license hygiene, patch filtering, and quality control.
- Distinguish the small set of high-signal PRs from the majority of noisy, trivial, poorly scoped, or unverifiable changes.
- Design contamination and leak audits, particularly for tasks derived from public-adjacent codebases or histories where the solution may already exist in commits, issue trackers, forks, discussions, or model training data.
- Set the quality bar for what LH2 ships to frontier labs: tasks must be hard, realistic, verifiable, non-guessable, and economically valuable.
What success looks like
- Within the first few months, you will have:
- Taken real repositories or operational workflows and converted them into reproducible, well-instrumented agent environments.
- Built verifiers and reward signals that withstand deliberate attempts to game them.
- Established clear standards for determinism, test isolation, flake rates, reset reliability, and evaluation integrity.
- Created a repeatable process for scaling a small number of high-quality tasks into a diverse task suite without collapsing diversity or leaking answers.
- Helped the company determine which agent capabilities and data verticals are most valuable to pursue.
- Produced measured evidence that our tasks and environments create useful training signal for capable models.
Must-have skills
- Deep, hands-on experience building environments, evaluations, benchmarks, or training infrastructure for LLMs, coding agents, or AI agents.
- Strong environment-engineering ability: Docker, dependency pinning, reproducible builds, sandboxing, test isolation, deterministic execution, and debugging difficult repository setup failures.
- Experience designing robust programmatic graders, verifiers, test suites, or reward functions - not just consuming existing benchmarks.
- Strong adversarial instincts: you naturally look for how a model, user, or agent could exploit a verifier, evaluator, simulator, test suite, reward function, or weak abstraction.
- Practical understanding of RL for language-model or agent training, including PPO/GRPO-style methods, KL regularization, reward shaping, advantage estimation, long-horizon credit assignment, and common causes of unstable or collapsed runs.
- Ability to reason about agent harnesses and rollout systems: tool APIs, ReAct-style loops, context management, trajectory logging, parallel execution, sandbox throughput, cost per rollout, and failure handling.
- Experience designing evaluation methodology, including contamination risks, leakage audits, held-out splits, seed variance, difficulty calibration, and reliable success metrics.
- Strong software-engineering judgment and the ability to work directly with unfamiliar, imperfect, real-world codebases.
- Ability to translate messy raw substrate - codebases, PR histories, operational data, product workflows, or expert knowledge - into a clear task specification, environment, verifier, and measured value proposition.
- High ownership and comfort setting a demanding research and engineering quality bar in a small, fast-moving team.
Nice-to-have skills
- Experience at a frontier AI lab, advanced applied-research lab, AI infrastructure company, or high-quality developer-tools company.
- Experience building coding-agent benchmarks, SWE-style task environments, browser-use environments, computer-use environments, or tool-using agent systems.
- Prior work on published benchmarks, open datasets, evaluation suites, RL environments, or post-training systems.
- Experience with large-scale PR or code-history mining, dataset curation, deduplication, code licensing, secret detection, or PII scrubbing.
- Familiarity with simulation systems, stateful application backends, synthetic data generation, multi-agent environments, or simulated users.
- Domain depth in software engineering, company operations, healthcare/clinical workflows, or another complex production domain.
- Experience operating large-scale sandbox, container, or rollout infrastructure with meaningful constraints around latency, reliability, and cost.
- Familiarity with evaluation contamination, benchmark integrity, and methods for identifying memorized or leaked solutions.
Click on Apply to know more.
