Design Engineer

Own the design system and the interface craft behind products used by enterprises and written by agents. About Sycamore Sycamore is building the trusted agent operating system for the enterprise. Our platform helps companies build, deploy, and orchestrate AI agents that take on real operational work, with the security and control large organizations need. We are a small, engineering-led team working directly with Fortune 500 enterprises. We have raised $65M from Coatue and Lightspeed, along with other investors and industry leaders. The role Products owns what enterprise users actually see and touch. Sycamore Build is our primary product surface: the place a customer describes what they need, watches agents build it, inspects what happened, approves what requires a human, and ships the result. Sycamore Govern is where a customer’s own AI program is registered, risk-assessed, approved, and audited. These are hard product surfaces to build well. The systems underneath are asynchronous, long-running, streaming, and non-deterministic, and the user still needs to feel oriented. A run can take minutes and produce a continuous flow of partial output. Something will need human approval halfway through. Something else will fail in a way that requires the user to understand what the agent was attempting. Making that legible is the work. The team owns full product slices. A change usually spans a route in the front end, the API behind it, the event stream that connects them, whatever agent behavior it triggers, and the measurement that tells us whether it helped. We do not hand designs to an implementation team or split ownership at the API boundary. There is also an unusual second audience. A large part of what Products builds is consumed by applications that agents write, not people. Our component library ships into generated applications that no engineer will review line by line, which means a component’s interface has to be legible enough that a language model uses it correctly the first time. Designing an API for a model is a genuinely different discipline, and it is one of the more interesting problems on the team. Working as a Design Engineer This specialization owns the design system and the quality of the interface itself: the component libraries, the token system, motion, layout, and accessibility. Two things make it unusual here. The first is the second audience. Our component library ships into applications that agents generate, and nobody reviews those line by line. A component whose interface is ambiguous will be used incorrectly at scale, silently. That inverts a lot of normal design-system practice: the interface has to be legible without documentation, the public surface is contract-tested so a breaking change fails at compile time, and consumers theme through tokens rather than forking components. The second is that we build on unstyled primitives and a compiled token system rather than assembling an existing kit. Themes are authored as token sources and compiled into custom properties in a perceptual color space, which makes systematic theming possible but means you are working a level below where most component work happens. There is also honest work to do. The accessibility patterns in our products are careful and largely hand-built, including live regions for streamed responses and a semantic layering scale, but the automated coverage behind them is thin. Closing that gap is real, valuable, and available to whoever takes this role. What the work looks like In one week, you might: Move Forge-specific component variants upstream into the shared design system behind the token contract, and shrink the adapter layer between them. Add automated accessibility coverage to the component harness, triage the resulting backlog, and codify the recurring rules as lint rules. Extend the token compiler so a customer’s own brand can flow safely into generated applications without letting untrusted input reach the stylesheet. Build a product flow that streams agent progress, tool calls, artifacts, and approval requests while keeping complex runtime state understandable. Take a long-running, failure-prone backend behavior and design the interface that makes it feel comprehensible rather than opaque. Own a slice end to end: the route, the API behind it, the events that connect them, and the measurement that says whether it worked. Improve the experience of a run that went wrong, so the user can see what the agent attempted and why it stopped. Design a component interface that both a person and a language model can use correctly without reading the implementation. Instrument a product decision properly, and be willing to conclude from the data that a feature did not help. What you will do Build and own product surfaces across Sycamore Build and Sycamore Govern, from the interface through the API and persistence behind it. Design interactions for asynchronous, streaming, long-running, and non-deterministic behavior, including partial output, interruption, and failure. Design and maintain typed contracts between front end and back end, and make drift a build failure. Turn powerful platform primitives into interactions that enterprise users can understand and trust. The environment you will work in Our current product environment includes React and TypeScript with TanStack Router and Query, Zustand for state, and Tailwind; Python cloud services on FastAPI with typed data models and PostgreSQL; server-sent events for streaming; durable workflows; and cloud-native deployment on Kubernetes. TypeScript is strict, and our component libraries are contract-tested so that a breaking change to a public interface fails at compile time rather than in a generated application. We test with Vitest and Playwright, including component harnesses and screenshot coverage, and we use coding agents, traces, evaluations, and production feedback as part of everyday engineering. This is context, not a checklist. We do not require previous experience with every framework or library in our stack. Strong engineers who understand systems, care about interface quality, and have shipped production software can become effective here without matching our tools one for one. What we are looking for 5-12 years of software engineering experience. We will make exceptions for exceptional people in either direction. Deep React and TypeScript at the type level, and experience composing unstyled primitives rather than adopting a prebuilt component kit. Evidence that you have shipped and operated product software people actually used, and cared about how it felt. Product judgment. You can find the real problem behind a request and choose a useful first version. Accessibility as a default rather than a checklist item, and the ability to reason about it from first principles. A security-minded approach to enterprise data, permissions, and what an interface should refuse to show. Comfort with non-determinism. The systems you are building interfaces for do not behave identically twice. AI-native. You use coding agents and modern models as a force multiplier while still owning architecture, correctness, and operational outcomes. Comfort with startup ambiguity, fast feedback loops, and broad ownership. A 30-minute introductory conversation. Two 60-minute technical interviews, one focused on systems design and one on coding. A take-home assignment where you build and present a real solution using the tools you would use on the job. Build the surface through which enterprises actually use AI agents. Work on interface problems that are genuinely unsolved, because the systems underneath behave unlike anything interfaces were designed for. Own product slices end to end rather than a layer of them. Build components consumed by both people and language models, which is a stranger and more interesting problem than it sounds. Join early enough to shape the product architecture and the design system. Receive competitive cash compensation and meaningful equity in the company you are helping build. Hard problems, real impact Trust architectures, memory systems, multi-agent coordination. The foundational layer that makes AI agents work in production. Small team, high ownership Every engineer shapes the product and the culture. No layers of process between you and the work that matters. Backed by the best $65M from Coatue, Lightspeed, Abstract Ventures, Dell Technologies Capital, 8VC, and notable industry angels. Grow with us Competitive compensation, meaningful equity, and a genuine focus on your growth as the company scales. #J-18808-Ljbffr