Principal Software Engineer

The Context Archimetis is building the operational reasoning system for heavy industry: combining agentic AI with rigorous data architecture and deterministic guardrails to bridge the gap between raw telemetry and high-level economic, operational, and energy optimization. Our systems operate in domains like refining, petrochemicals, metals, and building materials – environments governed by physical laws, hard constraints, and real safety and economic consequences. We are looking for a Principal Software Engineer to lead the future of our reasoning platform. This role is for someone who sees LLMs and agents not as chat interfaces, but as building blocks of a non-deterministic reasoning layer that must operate safely within deterministic operational constraints. This is not a prompt-engineering role, nor a model research role. It is a systems engineering role at the intersection of AI, data, and industrial reality. The Technical Mission 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. The Technical Requirements 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. Who This Role Is Not For Role 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.

How to Apply

Contact Aaron Brown (CTO & Co-founder) at [email protected] Bonus: If you have a GitHub or a technical write-up detailing a complex system you've built, please share it. We care more about what you've built than where you've worked or studied.