A complete application in a minute
Tailored resume and cover letter, ready to send.
Eccentric Machines in Brooklyn, NY is seeking a Principal Software Architect to lead Sentor’s motion orchestration and learning platform. This founding role offers ownership and hands-on work building architecture that coordinates multiple actuators into coherent motion and trainable behavior.
You will design interfaces, motion runtime, and training pipelines, working closely with the CTO, simulation lead, and embedded engineers to connect device capabilities with robot-level behavior.
Robotics & Motion Intelligence · Principal / Founding Technical Lead
Brooklyn, New York City · Full-time, in person
Competitive base salary of $200,000 to $275,000, benefits, and a significant founding-level equity package. This is an early technical leadership role with meaningful ownership and the opportunity to build a foundational part of the Sentor platform.
Eccentric Machines is a venture-backed company developing Sentor, a stealth, patent-pending invention that rethinks the electric motor from first principles, with the potential to fundamentally change actuation across robotics and beyond.
Sentor is not a conventional motor with an AI layer added on top. We are developing a new actuation architecture that brings together motion, onboard sensing, and device-level intelligence to enable more responsive, precise, and adaptive machines.
We have raised a $5M seed round to advance our prototype toward production and are building our founding R&D team in Brooklyn.
Our ambition extends beyond individual actuators. We want to create the software platform through which intelligent actuators work together, learn coordinated behaviors, and turn those behaviors into useful and beautiful physical motion.
We are looking for a Principal Software Architect to lead the architecture and development of Sentor’s motion-orchestration and learning platform.
Your core responsibility will be to build the software that coordinates multiple Sentor actuators into coherent motion and the infrastructure and models that allow those coordinated behaviors to be trained, evaluated, and improved.
This role sits at the intersection of robotics software, motion control, machine learning, simulation, and distributed real-time systems. You will work directly with our co-founder and CTO, simulation lead, and embedded intelligence engineers to connect device-level capabilities with robot-level behavior.
Our edge intelligence work focuses on what an individual actuator can sense, infer, and do locally. This role focuses on what a system of those actuators can accomplish together. You will define how responsibilities are divided between local control, multi-joint coordination, learned motion policies, and higher-level task commands.
This is a hands‑on founding role. You will make architectural decisions with our CTO , write production software, develop training workflows, and test the resulting behavior on physical hardware.
This role is highly iterative and collaborative. You will work closely with our co-founder and CTO and the engineering team to translate hypotheses into executable software, test them in simulation and on hardware, and refine the architecture as we learn.
We value clear technical direction without unnecessary infrastructure or prolonged design cycles. Start with a working motion capability, understand its limitations, and build the foundations needed to expand it.
The right person can balance immediate prototype needs with long-term architectural decisions knowing what to make robust now, what to keep flexible, and what not to build yet.
You will define the software architecture that connects individual actuators, coordinated motion, simulation, and higher-level applications.
Establishing interfaces for device commands, feedback, state estimates, motion requests, and fault reporting.
Designing the motion runtime, including scheduling, time synchronization, communication, and explicit latency and compute budgets.
Separating training infrastructure from deployed execution, and defining where local control, coordinated control, and learned behavior should run.
The goal is a coherent and modularized architecture that can evolve from an early test assembly into more complex machines without requiring a complete rewrite.
You will build the software that turns a collection of actuators into coordinated physical behavior.
Translating desired movements into coordinated commands while accounting for joint relationships, loads, contact, and actuator limits.
Developing trajectory execution, feedback coordination, and motion primitives that can be composed into more complex behaviors.
Handling timing variability, conflicting commands, device faults, and degraded operating conditions with defined limits and fallback behavior.
You will work with the embedded team to preserve fast local responses while enabling system-wide coordination. The objective is not to force every decision through a single controller, but to establish the right division of responsibility.
You will lead the software and learning architecture for models that generate and adapt coordinated motion.
Our longer-term ambition is to develop large motion models that learn reusable physical behaviors from simulation, demonstrations, and real‑world interaction. The immediate task is to establish useful capabilities and a rigorous path to scaling them.
Building workflows for training and evaluating motion policies, using approaches such as reinforcement learning, imitation learning, sequence modeling, or hybrid physics-and-learning methods where appropriate.
Defining observations, action representations, objectives, and constraints that reflect what Sentor hardware can actually sense and execute.
Developing reproducible training pipelines, scaling experiments as justified, and evaluating whether learned behaviors transfer across loads, configurations, and operating conditions.
We care about the quality of motion and the evidence behind it, not model size for its own sake. You should be comfortable starting with focused models and conventional control baselines, then expanding complexity when it produces a measurable benefit.
You will connect our actuator‑modeling work to system‑level simulation and learning.
The simulation lead will develop the detailed physics of the actuator. You will help turn those insights into representations and interfaces suitable for coordinated motion, controller development, and training.
Building compatible command and observation interfaces across simulated and physical devices, with explicit treatment of differences between them.
Creating multi‑joint simulation environments that account for geometry, gravity, contact, and kinematic dependencies.
Developing software‑in‑the‑loop and hardware‑in‑the‑loop tests, identifying simulation‑to‑hardware discrepancies, and feeding those findings back into modeling and training.
The goal is a repeatable path from simulated behavior to validated hardware behavior, not an impressive simulation that cannot survive contact with the real machine.
You will establish the engineering foundation for learning from every experiment.
Capturing synchronized sensor measurements, actuator commands, configuration information, and outcomes in datasets that can be replayed and analyzed.
Versioning datasets, models, software, and simulation configurations so results can be reproduced and regressions traced.
Building evaluation and release workflows that measure motion quality, robustness, timing, and resource use, with staged deployment and rollback.
Success means we can explain why a new model or controller is better, where it remains unreliable, and whether it is ready to run on hardware.
You will help lay the software foundation for Sentor Motion Studio: the environment through which engineers can configure systems, develop motion behaviors, run experiments, and deploy validated capabilities.
Defining APIs, software development kits, and configuration tools for describing actuator assemblies and commanding motion.
Supporting integration with robotics tools and applications, including ROS‑based systems and URDF robot descriptions.
Establishing code quality, testing, documentation, and architectural standards that allow the software team and platform to grow.
The initial priority is a useful engineering platform. Developer‑facing product capabilities should grow from real workflows and needs not precede them.
We are looking for someone who has taken responsibility for complex software that interacts with the physical world and has remained close enough to the implementation to understand why it succeeds or fails.
You may come from robotic manipulation, legged robotics, autonomous systems, industrial automation, surgical robotics, advanced motion control, or robotics‑learning platforms.
Hands‑on software architecture and implementation: experience designing substantial robotics or physical‑system software, with strong C++ and Python skills.
Motion and controls understanding: practical knowledge of kinematics, dynamics, state estimation, trajectory execution, and closed‑loop behavior.
Applied machine learning: experience implementing training and evaluation workflows for physical behavior, ideally with deployment and validation on real hardware.
Timing and systems judgment: experience reasoning about concurrency, communication, latency, synchronization, and the consequences of failures.
Technical leadership: the ability to make sound trade‑offs, communicate them clearly, work across disciplines, and establish engineering practices in a small team.
You do not need to be the leading specialist in every part of the stack. You do need sufficient depth to own the architecture, make substantial hands‑on contributions, and recognize where specialist expertise is required.
Software and systems: C, C++, Python, Linux, JSON, PyTorch, JAX, TensorFlow / Keras, CUDA, NVIDIA Warp, ONNX, concurrent programming, real‑time interfaces, microservices, ZeroMQ / MQTT, testing, profiling, and continuous integration. CAD including STEP/IGES/STL/OBJ etc.
Robotics and simulation: ROS / ROS 2, URDF, Movelt 2, Xacro, SRDF, SDF, OpenUSD/ USD, MuJoCo, NVIDIA Isaac Sim, Isaac Lab, GR00T, Jetson, π‑series, OpenVLA, skrl, Gazebo, Drake, PyBullet / Bullet, SAPIEN, Webots, Genesis, RaiSim, Unity, MATLAB Simscape Multibody, and/or comparable environments.
Relevant Mathematics and Engineering knowledge: Forward and inverse kinematics, Jacobians and singularies, DoF and redundant manipulators, coordinate transformations, quaternions; tree, graph, and constraint based kinematic representations; floating base and mobility, backdrivability; mass, inertia, friction and damping, tribology and collision geometry; harmonics and vibration, kinematic calibration. Sensor integration. SLAM, Kalman filtering. Synchronization, latency, sampling rates. Hardware watchdogs. Telemetry.
Kinematic and dynamic computation libraries: Pinocchio, Orocos KDL, TRAC-IK, IKFast, RBDL, HPP-FCL / FCL, CasADi, Crocoddyl, TSID, Eigen, SciPy
Algorithms: PPO, SAC, TD3, DDPG, A2C, Model based RL, Offline RL, hierarchical RL, Multi-agent RL, curriculum learning, Reward shaping and reward learning, Exploration and experience replay, policy distillation, Transfer learning, Meta-learning and continual learning, Imitation learning.
Techniques: Domain Randomization, Dynamics randomization, Sensor and actuator noise modeling, Sim-to-Sim comparison, Real-to-sim calibration, Digital twins, HIL, SIL, Online adaptation, Residual learning over classical controllers, Policy fine‑tuning using physical data, Robustness testing.
Learning and experimentation: PyTorch or JAX, reinforcement and imitation learning, GPU-based training, Factorial testing, experiment tracking, dataset management, and model deployment.
Familiarity with embedded software and device communications is valuable, but this is not solely