UI Engineer - Full-Stack (React/TypeScript, Python)

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.

• 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

• 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

• 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

• Contribute to a TypeScript- or Python-based CLI

• Design consistent interaction patterns across web and CLI

• Lay groundwork for potential future mobile interfaces

• 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

• 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

• 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

• 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.

• 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.