Product Engineer: Agentic UX

An engineer that designs the experience of working with agents. You own how Bonsai looks, feels, and behaves across the product: the visual direction of every screen, the interaction language that ties those screens together, and the core agentic flow and chat conversation. You decide when an agent’s answer should be text, a component, a structured result, or something else, then design and build the system that makes those choices feel coherent.

You take ideas from first principles to a polished experience in code and iterate with users.

These are examples, not lanes. You will move between them, while taking real ownership of the ones that match your interests.

• One product across many surfaces: Bonsai includes sessions, skills, memory, plugins, and workflows. Each can be useful on its own, but people should feel they are using one product. How do you create a visual and interaction language that holds together as the surface area grows?

• The right shape for an agent’s work: An agent might answer with prose, a list, a table, a form, a timeline, or an interactive surface. When should each be used? How much should be visible now, and what should stay one step away?

• A conversation people can trust: People need to understand what an agent is doing, steer it while it works, review its output, and recover when it fails. How should streaming answers, tool calls, approvals, parallel work, and uncertainty feel in the core chat?

• A system people and agents can extend: Engineers, PMs, plugins, and agents all create UI. How do you encode enough visual and interaction judgment into tokens, components, examples, and checks that new work feels like Bonsai by default?

• Set visual direction across the product: typography, color, layout, density, motion, and the quality bar for every screen.

• Design and build core agentic flows: chat, streaming responses, tool calls, approvals, progress, errors, and the points where a person takes control.

• Define how agent output becomes interface: choose when to use text, components, structured data, or another interaction, then build the primitives and patterns that make the choice consistent.

• Build cross-screen UX patterns that make depth easy to reach. Day one should be simple. Day thirty has serious depth, and it still feels simple.

• Own the design system and its operating layer: components, tokens, prototyping tools, examples, and visual or accessibility checks that keep the product coherent.

• Prototype quickly in the real system, test with users, and turn what works into production code that other people and agents can build on.

• You are comfortable being both designer and engineer. You care about product quality at the level of visual direction, interaction details, and shipped code.

• You design in code. You can build polished, accessible frontend systems without waiting for wireframes, and you know when an abstraction helps or gets in the way.

• You can hold the whole product in your head. You notice when two screens teach different mental models, and you know how to bring them back together.

• You have strong instincts about interaction design: hierarchy, timing, progressive disclosure, feedback, and the difference between an answer and an interface.

• You use agents heavily and have opinions earned from real work about what makes AI interaction clear, useful, and trustworthy.

• You have taste, and you can explain why the version you kept beat the ones you threw away.

• You are comfortable with ambiguity. The design language, agent patterns, and product conventions are still being made.

• You’ve designed and shipped a desktop app.

• You’ve built a design system, prototyping tool, or visual verification workflow used by other engineers.

• You…