1X에서 휴머노이드 로봇 NEO의 핵심 C++ 인프라를 설계하고 운영할 엔지니어를 찾습니다. 5년 이상의 성능 최적화 경험과 Linux 시스템 프로그래밍 역량이 필수입니다. 센서 파이프라인, 모터 제어, IPC 계층을 구축하여 로봇의 안정성과 성능을 책임지게 됩니다. 물리적 AI 시스템의 확장성을 고민하는 분들에게 최적의 기회입니다.
We’re building humanoid robots that work in home - doing the chores, handling the tasks, and giving people their time back. Simple, but it’s not.
To do this right, we have to solve robotics, AI, manufacturing - at the same time, at scale, in a form factor that has to be safe enough to live with your family. If you’re inspired by this, you’ll thrive here. We’ve been at this since 2014 and we’re at the point where the hard problems are behind us and the hard work is in front of us.
NEO is our flagship - a home robot designed to move, learn, and operate in the real world alongside real people. We’re not demoing it - we’re shipping it. We’re excited to meet you, if this excites you.
If you’ve spent your career working on problems that matter and want to see them actually reach the world - this is that moment. We’re scaling, we’re hiring with intention, and we need people who want to build something that will genuinely change how humans spend their time - safely creating abundance for all.
The Foundations team builds and owns the core C++ infrastructure that NEO’s entire stack runs on—sensor pipelines, motor control interfaces, inter-process communication, and the foundational libraries that ship on every robot. Our code executes thousands of times per second on hardware moving through the real world, and its correctness and performance directly determines what every other team can build and ship. If you want to work on the systems layer that makes physical AI possible at scale, this is that team.
Own the foundational C++ infrastructure that NEO’s brain and nervous system depend on ensuring it is fast, deterministic, and reliable as we scale from prototypes to thousands of robots in homes and warehouses. This is critical-path work: the latency, correctness, and maintainability of sensor pipelines, motor control loops, and IPC layers directly determines what the perception, planning, and controls teams can ship. Every clean interface introduced, every regression caught, and every millisecond saved here multiplies across every robot we deploy.
Own and continuously improve real-time C++ infrastructure: sensor pipelines, motor control interfaces, deterministic scheduling such that dependent teams can build on it without hitting foundational performance or reliability blockers
Establish performance as a measurable standard: deliver benchmarking, flamegraph tooling, and regression tracking that catches latency or throughput drift before it reaches production
Build the IPC and serialization layer connecting perception, planning, and actuation: lock-free queues, memory pools, shared-memory buffers with clean interfaces that other engineers trust and build on
Ship foundational libraries that run reliably on thousands of robots in homes and warehouses, not just prototypes in the lab
Thinks in cycles, cache lines, and budgets designing systems around latency, memory, and bandwidth constraints and can explain exactly where time and memory go under load
Deep Linux and systems fluency debugging across toolchain, ABI, kernel interfaces, and cross-compilation; uses profiling, tracing, and assembly inspection as everyday tools, not last resorts
Interface-first thinker writing code with clear contracts, minimal dependencies, and obvious correctness that other engineers reach for when building higher-level systems
Reliability-oriented under pressure shipping real-time systems where failure has physical consequences, and treats deterministic behavior and clean failure modes as engineering requirements, not afterthoughts
5+ years shipping production C++ in performance-critical systems: robotics, autonomous vehicles, HFT, game engines, OS/runtime, compilers, or HPC
Demonstrated ability to profile, benchmark, and debug at the systems level: flamegraphs, perf counters, assembly inspection, and Linux kernel interfaces
Proven track record of writing systems code other engineers build on clean interfaces, minimal dependencies, deterministic behavior under load
Experience with real-time or safety-critical systems where latency guarantees and failure modes have physical consequences
Familiarity with lock-free data structures, memory pools, and shared-memory IPC patterns
Experience with cross-compilation toolchains and embedded Linux targets
Background in robotics, autonomous vehicles, or other physical systems
Team members at 1X who thrive here are builders. They move fast, own their work completely, and treat time like it’s the one thing you can’t get back - because it is. They say what they mean, finish what they start, and hold themselves to a standard before anyone has to ask. We push each other to be better, and we do it with honesty and respect. =
$200,000 – $280,000 + Equity
Comprehensive medical, dental, and vision coverage
Generous paid time off, company holidays, and parental leave
401(k) plan with company match (100% on the first 3% of contributions, 50% on the next 2%)
Flexible Spending Accounts (FSA) and Health Savings Accounts (HSA) options
Commuter benefits (transit and parking)
Short-term and long-term disability, and life insurance
Employee Assistance Program (EAP) for mental health, financial, and personal support
Onsite snacks and catered lunches
1X is an Equal Opportunity Employer. All qualified applicants will receive consideration for employment without regard to race, color, religion, sex, gender, gender identity or expression, sexual orientation, national origin, ancestry, citizenship, age, marital status, medical condition, genetic information, disability, military or veteran status, justice system impact, or any other characteristic protected under applicable federal, state, or local law.
