To get the best candidate experience, please consider applying for a maximum of 3 roles within 12 months to ensure you are not duplicating efforts.
Job Category
Software Engineering
Job Details
Applications will be accepted until 10/05/2026.
*Please note for the right person, we would consider a fully remote employee*
The Experience:
We are looking for an unusual kind of engineer: someone who can reason deeply about data-intensive and distributed systems, then turn that complexity into a product people can understand, trust, and use.
You may have built infrastructure, control planes, developer platforms, data systems, or deeply technical enterprise products. You understand that the hardest systems problems are not solved when the backend works. They are solved when users can form an accurate mental model of the system, take powerful actions safely, diagnose what happened, and recover when things go wrong.
That challenge is becoming more interesting in an agentic world. Interfaces are no longer just collections of pages and workflows. Users may express intent rather than specify every step; agents may plan and act across complex systems; and the product must make those actions legible, governable, and reversible. We want someone who is excited to rethink what a control plane should be when agents are the primary actors and humans provide direction, oversight, and judgment.
This is a hands-on, high-leverage role at the intersection of systems architecture, product engineering, information design, and interaction design. You will help define not only how the system is built, but how its underlying concepts and behavior become a coherent product.
Telemetry, visualization, and human judgment:
We believe agents will increasingly do the work. The human interface must make it possible to see what was done, understand why it happened, recognize what requires attention, and make consequential judgments with confidence. In this model, telemetry is not a secondary operational concern or a collection of dashboards added after the fact. It is a core part of the user interface.
This role will own both control-plane and telemetry experiences: the surfaces through which users express intent, supervise agent activity, understand outcomes, investigate anomalies, and intervene when human judgment adds value. That requires more than displaying data. It requires choosing the right abstractions, preserving context and provenance, revealing causality where possible, and turning dense system behavior into information that people can grasp and act on.
We are looking for someone serious about the craft of information design-familiar with Edward Tufte's work and informed by thinkers such as Bret Victor, Ben Shneiderman, or Tamara Munzner-without being doctrinaire about any one approach. You should know how to use hierarchy, comparison, annotation, small multiples, progressive disclosure, and thoughtful visual density to make complex data genuinely understandable.
You should also have a strong point of view about the boundary between human and machine. Human-in-the-loop should be intentional, not a reflexive approval step placed in every workflow. Some decisions require human review before action; others are better served by clear policies, strong guardrails, complete auditability, and precise escalation when something falls outside expectations. You will help determine which model is appropriate, and design the evidence and interactions that make each model trustworthy.
What you'll do:
- Own and build core control-plane and telemetry experiences, from underlying domain models, events, and APIs through the user-facing product.
- Translate distributed-system concepts-state, dependencies, policy, identity, lineage, orchestration, failure, and recovery-into clear product primitives and interactions.
- Develop workflows for agent-executed work, including how human intent is expressed, permissions are enforced, activity is observed, outcomes are explained, and changes are audited or reversed.
- Create information-rich visualizations that help users understand state, change over time, relationships, anomalies, causality, and uncertainty without flattening meaningful complexity.
- Decide thoughtfully what should be done by an agent, what requires human judgment, and what belongs in a graphical interface, API, or programmable surface.
- Define patterns for human oversight, including when to require review before action, when to escalate exceptions, and when durable auditability is more valuable than synchronous approval.
- Prototype new interaction models, test them against real technical constraints, and carry the strongest ideas into durable production systems.
- Shape architecture and product direction through working software, clear technical judgment, and a strong point of view about usability.
You're Our Person If:
- Deep experience with data-intensive or distributed systems. You reason naturally about state, consistency, failure modes, asynchronous behavior, scale, and operational tradeoffs.
- Experience building platform or control-plane software-not only consuming infrastructure, but creating the systems through which other people understand and operate it.
- Experience directing multi-agent software development workflows and applying AI-native engineering practices, including specification-driven planning, implementation, review, and validation.
- Exceptional product and information-design instincts. You care about information architecture, visual hierarchy, interaction design, sensible defaults, progressive disclosure, and the details that make complex software feel coherent.
- Demonstrated ability to make high-dimensional, dynamic, or operational data grokkable to humans. You can move from raw events and system state to visual explanations that support real decisions.
- The ability and willingness to work across the stack. You can engage credibly with backend architecture and APIs while also building, prototyping, or closely shaping user-facing experiences.
- AI-native product judgment. You think beyond chat interfaces and copilots to questions of agency, context, permissions, observability, evaluation, trust, and human control-and you can distinguish when the right user is an agent from when it must be a person.
- A nuanced view of human-in-the-loop design. You can reason about risk, reversibility, uncertainty, accountability, and cost to determine when human intervention is necessary and when guardrails plus auditability are the stronger design.
- Comfort with ambiguity and first-principles product development. You can find the right abstraction before the requirements or organizational boundaries are fully settled.
Even Better If:
- Databases, distributed compute, orchestration, telemetry systems, event models, observability, governance, security, or developer infrastructure
- Information visualization, operational analytics, investigative interfaces, or other products that help people reason about complex and changing data
- Enterprise or technical products in which correctness, permissions, auditability, and operational safety matter
- Rich web applications or developer tools that expose complex systems without simply mirroring backend complexity
- AI agents, tool-using models, human-in-the-loop systems, or interfaces for planning and supervising automated work
- Zero-to-one product development, especially where the product model and technical architecture evolved together
