About the Role
We are building the control plane for AI agents in teams and companies.
As a UI Engineer, you'll help build the user-facing layer of that control plane - the web applications, workflows, and interfaces that make powerful agent infrastructure usable by real teams. You'll work alongside another senior UI engineer, with real ownership over specific surfaces and problems rather than sole responsibility for the whole frontend. Your core craft is React and TypeScript: component architecture, state management, performance, and the judgment to turn complex systems into interfaces people trust.
Our designers aren't just handing off mockups - several of them now build UI directly, using coding agents to write real production code. A big part of this role is partnering with them: helping them realize their design intent, reviewing and hardening what they ship, and bringing software engineering discipline — architecture, performance, testing, maintainability - to the frontend as it grows. You won't own visual design; that's their job. You'll help ensure the engineering quality of what ends up in production.
You'll also work with our Python backend - reading and extending services, shaping APIs, and making sure the frontend and backend evolve together.
You'll also help define a new interface paradigm: agents as an interactive modality - not just chat, but structured, controllable, and production-grade workflows.
If you love deep frontend craft, enjoy raising the bar on code quality without gatekeeping who gets to write it, want full-stack range without carrying backend architecture solo, and care about how humans interact with autonomous systems - we want to talk.
What You'll Own
Web Application & Product Experience (primary focus)
Help shape the architecture and implementation of our React + TypeScript web application, alongside our other senior UI engineer
Build high-performance, stateful interfaces for managing agents
Develop dashboards, policy configuration UIs, audit views, and workflow builders
Establish frontend patterns, component structure, and state management conventions the whole team - including designers - can build on
Own specific surfaces end-to-end, from first pass to production
Backend & API Work
Extend and maintain Python backend services that support the UI
Design or shape APIs for agent control, policy configuration, and observability
Work within a Kubernetes-native, cloud-based distributed system
Collaborate on schema design and data modeling where it affects the frontend experience
Agent-Native Interfaces
Explore agents as a new user interface modality
Design structured, interactive agent workflows beyond simple chat
Combine UI controls with agent reasoning
Experiment with hybrid patterns: visual + conversational + automated systems
CLI & Future Interfaces
Contribute to a TypeScript- or Python-based CLI
Design consistent interaction patterns across web and CLI
Lay groundwork for potential future mobile interfaces
Design Engineering & Collaboration
Partner directly with designers as they build UI using coding agents — pairing, reviewing, and unblocking them
Review and refactor designer-written code to meet engineering standards for architecture, performance, and maintainability
Help designers translate design intent into robust, production-ready code rather than one-off prototypes
Know when to harden code for production and when a good-enough prototype is the right call
Work closely with product and design to translate concepts into shipped software, and iterate quickly based on feedback
What We're Looking For
Strong Fit
Deep experience building production-grade web applications in React + TypeScript - component architecture, state management, performance
Comfortable reviewing, refactoring, and building on code written by others - including designers using AI coding tools - without being precious about who wrote it
Comfortable working in a Python backend: reading, extending, and occasionally designing services and APIs
Strong eye for interaction design and interface quality (we have designers for visual design - but you should have good taste)
Experience shipping SaaS products used by technical teams
Ability to translate complex backend systems into usable interfaces
Strong API design instincts
Bonus
Experience with design systems or component libraries
Experience building developer tools or control-plane software
Experience designing workflow builders or configuration-heavy interfaces
Experience with real-time systems or streaming UIs
Experience building CLIs
Familiarity with LLM-powered products or agent systems
Deeper distributed-systems or Kubernetes experience
What Makes This Role Unique
You'll help define how teams interact with autonomous agents.
You'll build interfaces for infrastructure-level systems, with full-stack range when you need it.
You'll operate at the intersection of product design, distributed systems, and AI.
You'll own specific surfaces end-to-end, from concept to production, as part of a small, senior UI team.
This is a high-impact, high-autonomy role. You'll influence product direction and user experience at this early stage of the company.
Who Thrives Here
Engineers who love frontend craft and want to see it shape a whole product.
People who enjoy pairing with designers and helping non-engineers ship better code, not just working alongside other engineers.
Builders who are comfortable dipping into Python and backend systems when needed, without wanting to own them.
People who are comfortable turning complexity into usable abstractions.
Those excited about inventing new human-AI interaction models.
Highly collaborative people who thrive working as part of a team.
People who thrive in early-stage startup environments - high ambiguity, fast iteration, done is better than perfect.
If you want to build the interface layer for the agent-native era - let's talk.
