Environment Engineer

Reinforced Learning; Town of Tonawanda (NY); On-site; USD 120,000 - 180,000; Full time

Job summary

Reinforced Learning in Town of Tonawanda, NY, seeks a backend-focused engineer to build environments powering customers’ agents learning. You’ll develop services behind tools, manage state resets, and ensure reproducible task versions across episodes.

You’ll ship deterministic systems in Python or TypeScript, using containers and sandboxed interfaces. You’ll design episode instrumentation to replay agent experiences and support reproducible simulations across runs.

Qualifications

• Strong backend engineering in Python or TypeScript.
• Experience building APIs, sandboxes, test harnesses, or simulators.
• Ability to ensure deterministic behavior in stateful systems.
• Ability to read a trajectory and determine whether the environment or agent caused an issue.

Responsibilities

• Build Stateful environments with working tool interfaces (terminals, editors, spreadsheets, ticketing systems, internal APIs).
• Implement snapshot and reset to start from a known state and finish with a checkable state.
• Version tasks, fixtures and verifiers to ensure reproducibility over time.
• Instrument episodes so researchers can replay what was seen, did, and rewarded for.
• Turn written tasks into runnable environments with task designers and domain experts.

Skills

Backend engineering

Python

TypeScript

Containers

Isolation

APIs

Test harnesses

Determinism

Trajectory analysis

Tools

Docker

Sandboxing

CI/CD

Job description

The role

Environments are where our customers’ agents learn. Each one is a stateful world with real tools, a hard task and a verifier that can’t be gamed. You’ll build them: the services behind the tools, the state that resets cleanly between episodes, and the task versions that stay reproducible months later.

What you’ll own

• Stateful environments with working tool interfaces: terminals, editors, spreadsheets, ticketing systems, internal APIs.
• Snapshot and reset, so every episode starts from a known state and finishes with a checkable one.
• Versioning of tasks, fixtures and verifiers together, so a result from March can be reproduced in September.
• Episode instrumentation, so researchers can replay what an agent saw, did and was rewarded for.
• Turning a written task into something that runs, with task designers and domain experts.

What you bring

• Strong backend engineering in Python or TypeScript, with containers and process isolation.
• You’ve built systems other people run against: APIs, sandboxes, test harnesses, simulators.
• You care about determinism. Flaky state bothers you.
• You can read a trajectory and tell whether the environment or the agent went wrong.

Helpful, not required

• Agent frameworks, tool-calling APIs or RL training loops.
• A mock of a real system you built that was convincing enough to fool a model.