Member of Technical Staff, Core AI

Build the runtime, evaluation, and learning systems that every agent on the platform depends on. 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. Where you could focus Core AI owns the horizontal runtime, intelligence, and improvement capabilities that Product and Infrastructure both depend on, along with the Sycamore Build experiences that make them usable, and engineers here own end-to-end slices from cloud service and API design through the React interface. Within that, the team covers four related areas. You do not have to pick one to apply, and we would rather you did not try: the boundaries between them are ours, and they are not something you could reasonably infer from outside. Tell us what you have built and we will work out the fit together. The agent runtime. Multi-turn sessions, model routing, tool execution, memory, durable workflows, and the APIs that expose them. The hard part is correctness across long horizons: surviving retries, provider interruptions, partial failure, and context growth without losing the thread. Harnesses and environments. An agent that writes and runs code needs somewhere to do it. That environment has to start fast, isolate genuinely untrusted execution, reach only the services it legitimately needs, and carry credentials it can use but never read. The same area owns the verification layer that decides whether what an agent produced actually works, which has to be incapable of disguising a broken result as a missing feature. Evaluation. Agent quality is genuinely hard to measure. A change that looks better on a handful of examples often is not, a judge model can be confidently wrong in the same direction as the system it grades, and the metrics that are easiest to collect are proxies for what you actually care about. This is where the offline suites, replay corpora, and statistical discipline that gate a release come from. Self-improving systems. Every agent run produces evidence, and almost all of it is currently thrown away. This area turns it into improvement: structured trajectories at fleet scale, failure clusters surfaced from production rather than guessed at, and proposed changes that are versioned, measured, staged, and reversible. Nothing here modifies itself silently. What you will do Develop the learning data plane around agents: structured trajectories, feedback and outcome signals, offline datasets, lineage, privacy controls, and reliable links between an agent version and its behavior. Create evaluation systems for task completion, tool use, long-horizon behavior, safety, latency, cost, accessibility, and business outcomes, and own the credibility of the numbers they produce. Design experiment and versioning systems for comparing changes through replay, shadow traffic, canaries, or controlled rollouts, with clear promotion and rollback criteria. Design typed tool interfaces and protocol-based execution across internal capabilities and customer-authorized services. Develop memory extraction and retrieval while enforcing tenant, user, and project visibility boundaries. Build durable orchestration for long-running tasks, checkpoints, approvals, handoffs, timers, and human-in-the-loop interactions. Own the execution environments agents run in, including isolation, startup performance, resource limits, and cost, and the harnesses that decide whether agent output actually works. Design the policy layer that gates self-modification, so a proposed change is staged and tested rather than applied silently. Publish reliable APIs, event-driven interfaces, reusable libraries, and pluggable improvement strategies that work across different agent categories and enterprise deployments. Join customer conversations when a repeated requirement or production outcome reveals a missing horizontal capability. The environment you will work in Our current Core AI environment includes Python cloud services; React and TypeScript product surfaces in Sycamore Build; asynchronous and streaming systems; typed APIs and data models; relational and vector data; durable workflows; protocol-based tool execution; multiple model providers; and cloud-native deployment. This is context, not a checklist. We do not require previous experience with every language, framework, model provider, cloud platform, database, or infrastructure tool in our stack. Comparable experience building distributed runtimes, experimentation platforms, retrieval or recommendation systems, workflow engines, developer platforms, or production AI systems is highly relevant. What we are looking for 5-12 years of software engineering experience. We will make exceptions for exceptional people in either direction. Strong backend and distributed-systems fundamentals, including typed API design, asynchronous workflows, persistence, reliability, and production debugging. Real depth in at least one of the areas above, and genuine interest in working across the others. An empirical approach to AI quality: you can form a hypothesis, design a useful evaluation, interpret noisy evidence, and distinguish a real improvement from movement in a proxy metric. The ability to reason about retries, idempotency, partial failure, long-running state, concurrency, latency, cost, experiment design, and safe rollout. A security-minded approach to multi-tenant systems, identity, authorization, credentials, tool execution, privacy, and auditability. Product judgment. You can find a durable abstraction behind a real requirement without generalizing too early or freezing customer-specific behavior into the platform. AI-native. You use coding agents and modern models as a force multiplier while still owning architecture, correctness, evidence, and operational outcomes. Comfort building product-facing software. You can work in React and TypeScript when a capability needs a great interface, and you can reason about streaming state, accessibility, and end-to-end user experience. Comfort with startup ambiguity, fast feedback loops, and broad ownership. Any of these is a strong signal for a particular area, and none is required: production Kubernetes work deep enough to have written controllers rather than only configured them; a real understanding of isolation boundaries and what each one does and does not contain; genuine comfort with statistics, including the ways an experiment can mislead you; experience with trajectory or event data at scale, including the joins, lineage, and privacy handling that make it usable; and judgment about when not to automate at all. Experience with reinforcement learning, preference learning, reward modeling, post-training, continual learning, ranking, causal inference, or large-scale experimentation is valuable but not required. We care more about whether you can connect learning ideas to production evidence and reliable systems than whether you have used a particular technique. Engineers from agent-runtime, distributed-workflow, retrieval, recommendation, experimentation-platform, integration-platform, developer-platform, or production applied-AI backgrounds often do well here. We care more about the systems you personally built, measured, and operated than a particular company, school, language, or model vendor. 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 cloud services that help enterprise agents learn from production experience. Ship Core AI capabilities end to end in Sycamore Build, from cloud service and API design through the React experience customers use. Turn production outcomes into governed improvements used across customers. Shape how feedback-driven learning, agent evaluation, and safe self-improvement work in a high-trust enterprise setting. Join early enough to shape the Core AI architecture and engineering team. 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 Sycamore