New opportunity

Robot Learning Engineer

Dexmate · Singapore

About this role

Dexmate is hiring a Robot Learning Engineer for its Singapore office to develop end-to-end learned models for general-purpose robot manipulation and control. The on-site role spans the robot learning pipeline, from multimodal data processing and large-scale training to deploying policies on physical hardware. Its focus may be tailored toward policy learning, training infrastructure, or real-time inference.

Responsibilities

Design, train, and evaluate learned policies for manipulation and whole-body control, including imitation learning, reinforcement learning, and vision-language-action-style architectures.
Deploy and validate models on physical robots; tune real-world performance and connect policy development with controllers and hardware.
Run experiments across simulation and real robots, collect data, diagnose failures, and measure improvements.
Own training infrastructure for job scheduling, checkpointing, metrics, and logging, and scale distributed training across GPU clusters.
Build tools for research debugging, visualization, and experiment analysis. Collaborate with controls, embedded, and hardware teams to make research systems deployable.

Minimum qualifications:

Master’s or PhD in Robotics, machine learning, computer science, or a related field, or equivalent practical experience.
Hands-on experience training and deploying ML models, ideally with PyTorch; a background in robot learning, imitation or reinforcement learning, or learning-augmented control.
Experience moving models from research into deployment rather than only evaluating offline benchmarks, and the ability to build, operate, and iterate on systems end to end.

Preferred qualifications

Experience with vision-language-action models, video generation architectures, or robot foundation models; deployment of learned policies on manipulation, legged, or humanoid robots; or high-performance serialization formats such as Protobuf and MCAP.
Publications at top-tier venues such as ICRA, IROS, CoRL, RSS, NeurIPS, or ICML are a strong plus.

For full details about this role, click “Apply on company site” to view the employer’s original posting.

Skills for this role

Robot learningRobot manipulationWhole-body controlImitation learningReinforcement learningVision-language-action modelsMultimodal data processingModel trainingPolicy deploymentSimulationDistributed trainingGPU clustersPyTorchReal-time inferenceExperiment designDebuggingData collectionResearch toolingVisualizationLearning-augmented controlRobot foundation modelsVideo generation architecturesProtobufMCAP

Checking your profile…

Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.

Understand the role

What matters most

Develop learned robot policies
The role calls for designing, training, and evaluating manipulation and whole-body control policies, including imitation learning, reinforcement learning, and VLA-style approaches.
Make policies work on physical robots
Dexmate emphasizes deployment and real-world validation, with iteration across the policy, controller, and hardware rather than stopping at offline benchmarks.
Drive measurable experimental progress
Responsibilities include processing multimodal data, running simulation and robot experiments, collecting data, diagnosing failures, and using debugging and visualization tools to measure improvement.
Own scalable training systems
The posting assigns ownership of job scheduling, checkpointing, metrics, and logging, alongside scaling distributed training across GPU clusters.
Translate research across engineering teams
The engineer works with controls, embedded, and hardware teams to turn research needs into reliable, deployable systems. The role may be tailored toward policy learning, training infrastructure, or real-time inference.

Likely challenges to think through

Closing the simulation-to-hardware gap
A likely difficulty is that a policy that improves in simulation or offline evaluation may behave differently on a physical robot. Prepare to explain how you would isolate failure modes, collect targeted robot data, and decide whether to change the model, controller, or evaluation.
Balancing model capability with deployment constraints
Because the role spans large-scale models and potentially real-time inference, a plausible trade-off is policy complexity versus dependable on-robot execution. Prepare to discuss how you would measure both task performance and inference behavior before choosing a deployment approach.
Keeping rapid experiments interpretable at scale
Fast iteration across data, distributed training, simulation, and robots can make results hard to compare. Prepare a concrete approach to checkpointing, logging, and experiment analysis that distinguishes genuine policy gains from changes in data or test conditions.

Practice your answers

Technical practice

How would you prepare multimodal robot data for policy training?

What to coverSuggested preparation: Explain how you would align observations and actions, check data quality, and preserve information needed to diagnose failures. Discuss how processing choices could affect training and later evaluation on a robot.

When would you use imitation learning versus reinforcement learning for manipulation?

What to coverSuggested preparation: Compare the data and feedback each approach needs, and how you would evaluate whether a learned policy improves task performance. Explain what would motivate a change in approach after early experiments.

How would you evaluate a vision-language-action-style policy?

What to coverSuggested preparation: Describe how you would test whether language-conditioned behavior translates into successful robot actions, not just favorable offline results. Discuss trade-offs against a narrower policy for the same manipulation task.

How would you connect a learned whole-body policy to a robot controller?

What to coverSuggested preparation: Clarify which outputs the policy would provide and which responsibilities would remain with the controller. Explain how you would investigate performance problems that might arise from the policy, controller, or hardware.

How would you design an experiment that iterates between simulation and a real robot?

What to coverSuggested preparation: Define a measurable outcome and a way to compare runs, then explain how real-robot observations would inform the next simulation or training experiment. Address how you would distinguish a policy improvement from a change in test conditions.

What would you check before deploying a trained policy for real-time inference?

What to coverSuggested preparation: Discuss inference timing and the interface between model outputs and physical hardware as proposed validation concerns. Explain how you would test behavior on the robot and respond if offline performance did not carry over.

How would you operate training across a GPU cluster while keeping experiments reproducible?

What to coverSuggested preparation: Cover job scheduling, checkpointing, metrics, and logging, all named in the posting. Explain how you would detect failed or misleading runs and make comparisons across training jobs.

What research tools would you build to debug a failing robot policy?

What to coverSuggested preparation: Describe visualizations or experiment analyses that would help connect observations, policy outputs, and robot behavior. Explain how findings would lead to a specific data, model, or deployment change.

How would you assess whether a manipulation policy is improving?

What to coverSuggested preparation: Propose task-level measures alongside analysis of failure modes, rather than relying solely on training loss or an offline benchmark. Explain how you would compare policy versions on physical robots and interpret mixed results.

Where might Protobuf or MCAP fit in a robot-learning workflow?

What to coverSuggested preparation: These formats appear as a preferred qualification, so discuss them only if relevant to your experience. Explain the serialization or data-handling trade-offs you would examine for training, debugging, or deployment.

Behavioural practice

Tell me about a system you owned from model training through deployment and iteration.

What to coverSuggested preparation: Use a real situation, your specific actions across the pipeline, and the observed result. Explain what you changed after seeing deployment behavior rather than focusing only on offline performance.

Describe a time you worked with controls, embedded, or hardware colleagues to make a research result deployable.

What to coverSuggested preparation: Set out the technical disagreement or constraint, how you coordinated responsibilities, and the result. Be precise about your own contribution without claiming the team's work as yours.

Tell me about a robot-learning experiment that failed or produced an unexpected result.

What to coverSuggested preparation: Describe the situation, the evidence you collected to diagnose it, the action you took, and the measured outcome. Include what remained uncertain if the failure was not fully resolved.

Describe a time you had to choose between improving a model and improving the system around it.

What to coverSuggested preparation: Give a real situation, the trade-off you faced, what you prioritized, and the result. Connect your reasoning to reliable experimentation or deployment rather than presenting the choice as universally correct.

Sharpen your knowledge

Topics to prepare

Imitation and reinforcement learning for robot policies
Revision exercise: compare how you would train and evaluate an imitation-learned policy and a reinforcement-learned policy for the same manipulation task. The posting explicitly names both approaches for learned manipulation and whole-body-control policies.
Policy, controller, and hardware interaction
Revision exercise: trace how a learned policy's outputs would reach a controller and physical robot, then identify where a real-world failure could arise. The role explicitly calls for closing the loop between policy, controller, and hardware.
Simulation-to-robot evaluation
Revision exercise: outline an experiment that compares policy behavior in simulation and on a real robot, including a measurable outcome and a failure category. The posting calls for rapid iteration across both settings and measurable improvements.
Multimodal and vision-language-action policy design
Revision exercise: sketch the inputs, outputs, and training data for a VLA-style manipulation policy. Multimodal data processing and VLA-style architectures appear in the responsibilities; prior VLA experience is preferred, not a stated minimum.
Distributed training and experiment reliability
Revision exercise: explain how scheduling, checkpoints, metrics, and logging help a training run remain inspectable and recoverable across GPU clusters. The posting explicitly assigns ownership of this infrastructure.

Skills to revise

Train and evaluate a learned policy
Suggested exercise: use an existing, permitted robot-learning dataset to train a small policy in PyTorch, then record an evaluation result and a failure case. Hands-on model training and deployment are minimum qualifications; PyTorch is described as ideal.
Prepare multimodal robot data
Suggested exercise: define a consistent record for observations and actions, inspect a few sequences for alignment errors, and document how errors would affect training. The role spans ingesting and processing multimodal data.
Diagnose an experiment failure
Suggested exercise: review a simulated or previously recorded robot rollout, classify a failure, propose one change, and specify the metric that would test it. The posting calls for data collection, debugging, experiment analysis, and measurable improvement.
Operate a repeatable training run
Suggested exercise: configure a training run with checkpoints, logged metrics, and a restart test; explain how you would inspect it when scaled across GPU workers. This reflects the stated training-infrastructure and distributed-training responsibilities.
Plan a physical deployment check
Suggested exercise: write a validation checklist covering policy outputs, controller behavior, observed robot performance, and a decision to stop or iterate. The posting emphasizes deploying models on physical robots rather than relying only on offline benchmarks.

Your preparation checklist

Choose a role focus
The posting says the role may emphasize policy learning, training infrastructure, or real-time inference. Prepare a brief explanation of which area you would discuss most deeply and how it connects to the full robot-learning pipeline.
Prepare an end-to-end project walkthrough
Select a real project you can discuss from data processing and model training through evaluation and deployment. Bring a diagram, your specific decisions, measured results, and what you changed after failures; the posting emphasizes taking models beyond offline benchmarks.
Rehearse a policy design exercise
Sketch a proposed approach to a manipulation or whole-body-control task: observations, actions, data collection, policy choice, and evaluation. Be ready to compare imitation learning, reinforcement learning, and VLA-style approaches; this is preparation, not a stated interview format.
Build an experiment evidence sheet
Summarize an experiment you can substantiate with metrics, simulation-to-robot differences, failure diagnoses, and follow-up tests. The role explicitly involves iterating between simulation and physical robots to drive measurable improvements.
Map training and deployment decisions
Prepare a one-page system diagram covering job scheduling, checkpoints, metrics, logging, and distributed GPU training, alongside the path from policy output to controller and hardware. Mark which parts reflect your own experience and which are proposed designs.
Collect evidence for relevant qualifications
List specific examples of hands-on model training and deployment, ideally including PyTorch if applicable, and end-to-end system ownership. Separately note any applicable preferred experience—such as physical-robot deployment, VLAs, Protobuf or MCAP, or publications—without treating it as required.
Draft questions about the work
Ask how Dexmate divides work among policy learning, infrastructure, and inference; what physical-robot validation and success measures look like; and how robot-learning engineers work with controls, embedded, and hardware teams.

Availability last checked: 4 Nov 2026. Status can change after a check; confirm on the employer’s website. Report an issue · Our checking policy

KEEP EXPLORING

Similar AI jobs

Related skills and specializations in Singapore. Matched to this role, not your profile.

Explore more jobs

Finding similar opportunities…