Member of Technical Staff, Software Engineer

About Plato

Plato is an applied research lab building the foundational infrastructure to train specialized AI agents.

We turn real-world data streams into high-fidelity simulated environments that generate the training signal needed to make capable models. Our work supports frontier labs, hyperscalers, and enterprises building AI systems for complex, high-stakes work.

Today, only a handful of players can train models for capable work. Compute and algorithms are rapidly commoditizing, but reinforcement learning data remains the bottleneck. Plato is changing that by automatically scaling training environments from proprietary real-world data.

Why This Role Matters

Software engineering is central to Plato's product and research loop.

Our research and infrastructure only matter if they become systems that researchers, domain experts, and customers can actually use. We need product and platform software that can ingest messy real-world traces, turn them into usable workflows, expose the right controls for humans, and make model behavior legible across environments, rollouts, verifiers, rewards, and telemetry.

As a Member of Technical Staff, Software Engineer, you will build the product and systems layer that turns Plato's research and infrastructure into a usable full-stack RL pipeline.

Role Description

You will work across backend systems, product surfaces, data pipelines, internal tools, evaluation workflows, and customer-facing prototypes.

You might build Forge, the platform that imports traces, logs, recordings, and schemas; the interfaces that let humans tune scenarios, perturbations, and rewards; the services that turn raw streams into executable environments; or the tools researchers use to inspect rollouts and model failures.

This is not conventional product engineering. You will be building software in the middle of a fast-moving research loop, where the product surface, backend systems, data model, and customer workflow often evolve together.

You Will Work On

• Develop product surfaces for researchers, domain experts, and customer teams to inspect, tune, replay, and validate generated environments.

• Build backend systems for trace ingestion, schema handling, environment generation, task generation, scoring, and telemetry.

• Create internal tools that help researchers move faster across evals, rollouts, verifiers, rewards, and failure analysis.

• Turn customer workflows into robust software systems that can be reused across frontier labs and enterprise deployments.

• Ship pragmatic, high-quality software in a fast-moving, deeply technical team.

What We're Looking For

We're looking for someone who is excited to build software at the boundary of product, infrastructure, and AI research.

You may be a strong fit if you:

• Have strong product engineering taste and can build clear interfaces for complex technical workflows.

• Are comfortable working across backend systems, data pipelines, product surfaces, and internal tools.

• Can turn ambiguous customer or research workflows into robust, reusable software.

• Care about correctness, usability, observability, and iteration speed.

• Want to build systems that are part of the core training loop, not a wrapper around it.

How We Work

Being an engineer at an early-stage AI startup is not easy. These are the values we care about.

Ownership

We value teammates who bring novel ideas to the table, experiment, and see results through end to end. You'll have access to massive compute budgets to test large scale experiments.

Move Fast, Build Durable

Demand is growing faster than our team. We move quickly, prioritize ruthlessly, and ship systems that keep working under load.

Reality Over Narratives

Training data is incredibly fragile and prone to reward-hacking. We prioritize digging deep through data, manually if we have to, to garner deep intuition on retaining high quality throughput.

Stay Close to the Frontier

New AI capabilities rapidly change how we think about problems and what doors open. We stay close to the frontier of model capability, and encourage teammates to constantly share new findings and update their world model of what's possible.