Principal Software Engineer

You will be responsible for the capability, scalability, and architectural integrity of our reasoning platform. Core challenges include:

• Hybrid Reasoning Architectures: Designing systems that combine LLM-based planning and agents with symbolic logic, structured data models, optimization techniques (regression, LP/MIP), and physics-based simulation (thermodynamics, kinetics).
• Deterministic Guardrails for Non-Deterministic Agents: Building validation, constraint-checking, and middleware layers that ensure agent-generated analyses and plans are safe, feasible, and compliant with real-world operating constraints.
• Continuous & Proactive Reasoning: Enabling reasoning to run continuously over high-volume telemetry streams to detect issues and opportunities early-while managing compute cost, latency, and token budgets.
• High-Throughput Telemetry Integration: Architecting data pipelines that ingest, normalize, and contextualize high-frequency sensor data so it can be reliably understood and consumed by agentic systems.
• AI-Native Tooling & Productivity: Leading by example in using agentic developer tools (e.g. Claude Code, Cursor) to maintain high velocity without sacrificing clarity, testability, or architectural discipline., * You are primarily interested in prompt engineering or chat UIs. This role is about building the systems behind agentic reasoning: orchestration, validation, data flow, and constraints-not crafting chat experiences.
• You want to focus on model training or LLM research. We use frontier models as components. We do not train foundation models or publish model architecture research.
• You prefer greenfield prototypes over long-lived systems. This role involves owning production systems that must evolve safely over time, with backwards compatibility, observability, and operational discipline.
• You expect fast iteration without accountability. We move quickly - but our systems influence real operations. Designs must be defensible, failure modes understood, and guardrails explicit.
• You aren’t comfortable with Principal-level ownership. This role requires making hard architectural calls, living with their consequences, and helping others reason through tradeoffs. You will shape the problem space, not just execute within it.
• You rely on in-person proximity for effectiveness. Our team is remote-first, which means influence, clarity, and technical leadership are expressed through writing, async collaboration, and deliberate communication rather than hallway conversations., This role will be deeply satisfying for the right person-and frustrating for the wrong one. You probably should not apply if:
• You are primarily interested in prompt engineering or chat UIs. This role is about building the systems behind agentic reasoning: orchestration, validation, data flow, and constraints-not crafting chat experiences.
• You want to focus on model training or LLM research. We use frontier models as components. We do not train foundation models or publish model architecture research.
• You prefer greenfield prototypes over long-lived systems. This role involves owning production systems that must evolve safely over time, with backwards compatibility, observability, and operational discipline.
• You expect fast iteration without accountability. We move quickly - but our systems influence real operations. Designs must be defensible, failure modes understood, and guardrails explicit.
• You aren’t comfortable with Principal-level ownership. This role requires making hard architectural calls, living with their consequences, and helping others reason through tradeoffs. You will shape the problem space, not just execute within it.
• You rely on in-person proximity for effectiveness. Our team is remote-first, which means influence, clarity, and technical leadership are expressed through writing, async collaboration, and deliberate communication rather than hallway conversations.

• Strong Technical Fundamentals: We build in Python (Pydantic, FastAPI, Pandas, asyncio), but what matters most is how you think-your ability to reason through complex systems problems, craft elegant solutions, balance velocity and debt, and pick up new tools quickly. Deep Python expertise is a plus, not a prerequisite.
• Agentic Systems Experience: Proven experience building multi-agent or agent-orchestrated systems - whether via frameworks like LangGraph or custom state machines - that involve long-running tasks, tool invocation, feedback loops, and dynamic replanning.
• Distributed Systems Judgment: You are a systems thinker. You can reason clearly about service boundaries, APIs, caching, failure modes, schema evolution, and consistency tradeoffs. You are comfortable making - and defending - calls like GraphQL vs. gRPC, when to centralize vs. federate, and where eventual consistency is acceptable.
• Industrial Domain Empathy: This is not consumer software. You don’t need prior industrial experience, but you should be energized (not intimidated) by the fact that your code operates alongside physical processes with real safety and economic stakes, and that a factory cannot simply “reboot” if your code fails. We value pragmatic engineering judgment over formal perfection.
• Principal-Level Ownership: You are comfortable setting architectural direction, being the tie-breaker on hard decisions, and mentoring engineers through complex design tradeoffs.
• Our Culture: High-Sync / High-Trust / AI-Native
• High-Sync: We work remote-first, favoring fast feedback loops, focused technical discussions, and clear written communication-not meeting sprawl.
• High-Trust: No micro-management. We hire seniors because we trust your judgment on architecture, tech debt, and when to “build vs. buy”.
• AI-Native: We don’t just build AI; we use it. You will be encouraged to automate busywork so you can focus on the hard, high-leverage engineering problems.