Member of Technical Staff

Capy; San Francisco (CA); On-site; USD 210,000 - 300,000; Full time

Benefits offered by this job

Visa sponsorship

Relocation support

Flexible PTO

Medical, dental, and vision insurance

Equity

Job summary

Capy in San Francisco is hiring to own the entire product experience for AI coding tools. You’ll shape interfaces, agent loop, backend, and infrastructure across a multi-tool stack.

We value agent-native developers with TypeScript, Node, React production experience, and comfort across MySQL, Kubernetes, and messaging with NATS. Join a hands-on team building scalable engineering software.

Qualifications

• Experience with agent-based tooling or harnesses.
• Fluent in TypeScript with Node.js and React production experience.
• Comfortable across backend, frontend, and infra layers.

Skills

Agent-native

TypeScript

Node.js

React

MySQL

Kubernetes

NATS

Job description

About Capy

We're building the AI software engineer you hand real work to. A thread starts from Slack, Linear, the web app, the desktop app, or the API; Capy makes the change on a cloud machine or right on your own laptop, office Mac mini, or any device you've paired, opens the pull request, and handles CI and review feedback until it merges. Work moves between your devices and the cloud mid-thread, big work splits into parallel agents across those machines, a review agent reads every PR, and automations run on a schedule or on platform events. The age of the solo coder is over: developers stop babysitting single agent sessions and start orchestrating fleets of agents, together with their team.

We're a small team in San Francisco, backed by Y Combinator and tier-1 investors, shipping to teams that run Capy on production codebases every day. We build Capy with Capy: our own PRs, reviews, and automations run through it.

The role

AI coding is a crowded market now, and developers expect first-minute magic and a quality bar that holds across every surface. Meeting that bar means you will have to own the entire product experience and craft it with care.

"Full stack" here means the whole width of Capy: the interfaces developers direct agents from, the agent loop and its tools, the backend the loop re-plans from, the infrastructure the machines boot on, and the layer that talks to every frontier model. You'll make product decisions without a PM, design without waiting on a mockup, and solve the hard engineering problem yourself rather than handing it off. This is a role for people who build with taste and feel the gap between what exists and what should, then close it.

What you'll do

• Ship across the whole stack. One day is a new tool in the agent loop, the next is the React surface that shows what it did, the migration behind it, and the Kubernetes change that ships it.

• Set the standard for agent UX. Threads, tasks, diffs, reviews, live machine desktops streamed from our Rust remote desktop: twenty‑five agents running at once need an interface that stays legible.

• Design in code. Take a feature from rough idea to a polished, animated, keyboard‑first interface in the React web app and Electron desktop app.

• Build the backend the agent runs on. Effect services over MySQL (Vitess on PlanetScale), realtime fan‑out over NATS, the typed API and protocol every client shares, the git proxy, the worker that drains threads.

• Push what the agent can do. New tools, better verification, tighter loops with CI and review, smarter task orchestration, and the provider layer across Anthropic, OpenAI, Gemini, and the rest.

• Run the infrastructure. The Kubernetes clusters and IaC that deploy Capy, and the VM images and sandbox platform every cloud machine boots from.

• Direct Capy on Capy. Most of your day is writing specs, steering agents, reviewing their PRs, and fixing the harness when it lets them down.

• Talk to users. Developers running Capy on real codebases tell you what's wrong; you turn it into what ships that day.

Who you are

• Agent-native. Claude Code, Codex, Cursor, etc (or your own harness) is how you already work, and you have sharp opinions about where they fall short.

• Fluent in our stack. TypeScript 7 on Node 24 and React in production, and typed functional code (Effect or the like) you can read and write without a ramp. You've shipped against MySQL, run something on Kubernetes, and touched a message bus like NATS.

• Comfortable at every layer. A slow query, a broken websocket, a failing Helm release, and a misbehaving tool call in the same afternoon, and you don't wait for a specialist on any of them.

• Taste in interfaces. You notice the four‑pixel misalignment, you care about motion, hierarchy, and empty states, and you can point at shipped work that proves it.

• Independent product judgment. You make the call on what to build and how it should feel without a PM or designer defining the problem first.

• Fast without shortcuts. You verify your work, read your diffs, and would rather delete code than add an abstraction nobody uses yet.

• In San Francisco. In a room with people doing the same.

You might thrive here if

• You've felt the gap between an agent product that demos well and one you'd trust with your own repo, and you want to close it.

• You'd rather own a feature from idea to merge than hand it off halfway.

• You think the next five years of software engineering look nothing like the last five, and you want to be the one deciding what they look like.

Nice to have

• Effect in production, or Rust (our remote desktop is Rust).

• Sandboxed execution, VM images, remote desktops, or a git proxy you've built or operated.

• A model‑provider layer you've built, or direct work against Anthropic, OpenAI, and Gemini APIs.

• Design‑tool fluency (Figma or similar) on top of prototyping in code.

• Public work: open source, posts, demos, an active account on X.

• Founder or early‑employee experience.

Compensation

$200K – $300K salary plus 0.5% – 1.5% equity. Medical, dental, and vision. Flexible PTO. Visa sponsorship and relocation support.

How we hire

1. A 30‑minute call with a founder about what you've built and what you'd build here.

2. A take‑home you do with whatever agents you like, then a walkthrough of how you directed them and why.

3. A day in the office pairing with the team on real work.

4. Offer, usually within a week of the first call.