Technical Product Manager, AI Agents

Product.ai; Los Angeles (CA); On-site; USD 300,000 - 425,000; Full time

Job summary

Product.ai seeks a senior operator who can write precise specs for an AI agent loop and own the API that shopping agents call. You will define the rubric that determines when an agent's output ships and embed cost constraints into every feature spec.

You will work inside Cortex, shaping an API-driven product, MCP layer interfaces, and a charter that proves the seat is functioning while evolving the rubric as the system learns.

Qualifications

• Shipping an API or developer-facing surface
• Owning an eval or QA rubric shipped
• Backend engineering with product ownership or dev-tools PM experience
• Ability to model a system from interfaces

Responsibilities

• Write the spec an AI agent is graded against and own the API surface
• Define the eval rubric that governs when output ships
• Model cost per query and defend it within the spec
• Work inside Cortex directing coding agents and rubrics

Job description

We have one product-leader seat open, and we're running it as several doors so the level of the hire follows the person, not the job title. This door is for the technical-side path: an operator who came up through engineering, or who is technical enough to write the spec an AI agent loop is graded against.

Role Overview

Compensation $300k - $425k

You write the spec an AI agent gets graded against, and you own the door AI shopping agents call to reach us.

Product.ai (product.ai) is the verified truth layer for shopping: when a person or an AI agent needs to know what's actually true about a purchase, we answer with proof. SimplyCodes (simplycodes.com) is the first proof at scale, the code verification service, at about $22M a year in revenue. Profitable. Founder-owned since 2009, bootstrapped, no outside investors, no board. Fewer than twenty operators.

Why This Role Exists

We have one product-leader seat open, and we're running it as several doors so the level of the hire follows the person, not the job title. This door is for the technical-side path: an operator who came up through engineering, or who is technical enough to write the spec an AI agent loop is graded against.

AI shopping agents now call outside tools directly, through a protocol called MCP. Increasingly, the customer for a piece of our product is another AI deciding whether to call us. Someone has to own that surface: the API and MCP layer agents use, the definition of done that decides whether an agent's output ships, and the cost of every feature as a hard constraint on the spec. You work directly with the founder.

The System You'll Need to Model

• Agent-callable product surfaces. An API and MCP layer isn't a backend detail here. It's a product with its own users, except the user is an AI agent instead of a person, and the interface contract is the whole product.
• The spec as the evaluation. In a system where agents write the code, the spec has to double as a rubric something can be graded against. "Good" stops being a design opinion and becomes a testable definition you author.
• Cost as a spec-level constraint. Every feature carries a cost per query, and you size that cost into the spec itself, the way an earlier generation of PM sized headcount into a roadmap.
• Knowledge-graph answers, encoded for a machine reader. A person reading a verdict page absorbs nuance from layout and tone. An agent calling our API can't; it needs cost, provenance, and confidence expressed as fields it can parse and act on without a human in the loop. You decide what that schema carries and what it leaves out.
• What makes an agent choose to call you. An agent picks an endpoint the way a person never had to: on latency, schema stability, a trust score it can verify, and whether a version change will break its caller silently. You design for that decision.
• Cortex, the shared AI brain the company runs on. You'll work inside it daily, directing coding agents the way our founder does, and since August any operator here can change the rules the company runs on, live, without waiting on him.
• A fast-moving spec surface. The rules an agent is graded against today will not be the rules in a quarter. You rebuild the rubric as the system learns, instead of treating a shipped spec as finished.

If modeling that spec-as-rubric problem energizes you, keep reading. If it feels overwhelming or underspecified, this isn't the right fit.

What You Will Own

• The agent-facing product. The API and MCP surface AI shopping agents call: what it returns, how it versions, and what breaks a caller's trust. You write the interface contract the way another PM writes a screen.
• The eval-gated definition of done. For every feature you spec, you also write the rubric an agent loop is graded against before its output ships. The eval lives inside the spec from the first draft.
• The cost line, per feature. You model cost per query into every spec you write, and you can defend the number, not just the feature.
• The developer and agent relationship, on the product side. The commercial relationship with the platforms and developers who call this API belongs to our commercial seat. The shape of what they're calling, its reliability, and its roadmap belong to you.
• Your seat charter. Within your first quarter you co-sign a charter for this seat. It names one machine-checkable number that proves the seat is working, and a written split of what you decide freely versus what you bring to the founder.

The craft you must already own: writing a spec precise enough that an agent or an engineer could build the right thing from it, and reasoning about an API as a product. Comparable experience we accept: platform PM, developer-tools PM, or infrastructure PM work, even without "AI" in the title. What you'll grow into here: eval design as a first-class product skill, and directing coding agents as your default production system.

Who You Are

How you think. You form a working model of a system by reading its interfaces, not just its screens. You notice where your model is wrong and update fast. You can take a rough signal and reason your way to a scoped problem, without waiting for someone to hand you a fully written ticket. You write clearly, because a spec that isn't clear can't be graded.

How you work. You move between an architecture conversation with an engineer and a spec an agent can build from, same day, without needing a translator in the room. You treat agents as leverage, and you verify what they hand back yourself; you direct coding agents inside Cortex most days. Compute is cheap here. A redo cycle from a vague spec costs real time.

What you've probably built. You've shipped an API or a developer-facing surface with real external callers, or you've owned an eval or QA rubric a team actually shipped against. Adjacent roads count: backend engineering with product ownership, dev-tools PM, or infrastructure PM work where the customer never saw a screen. We care about the artifact and the reasoning more than where you did it.

Who this isn't for. It's wrong if you want to manage the relationship with the founder more than you want to own the spec; it fails here. It's wrong if you're drawn to the seat for how the title reads at a bigger company; the work itself is what we hire on here. It's wrong if you'd rather guard one lane, like only the API, and hand the eval design to someone else; here the two are the same job. It's wrong if this is a resume line before you move to a bigger title elsewhere; the seat charter you co-sign in quarter one is a multi-year commitment. And it's wrong if you can't independently model a system you didn't build yourself, because that's most of what you'll inherit on day one. You'll be happiest here if you want to own a spec end to end and be measured on whether an agent could build the right thing from it.

How We Evaluate

• Async video screen. About 15 minutes, on your own time. It replaces the recruiter screen.
• Calls with company stakeholders. Short conversations with the team.
• Conversation with the founder. How you model the system above, and where you'd start.
• Paid work trial. Real work in our real environment, at your stated rate, taking a live spec problem from intent to something an agent could be graded against.

Compensation & Ownership

Total first-year comp: $300,000 to $425,000 (base + performance-based ownership and profit-share programs). Base: $200,000 to $260,000.

Beyond base: eligibility for the company's ownership and profit-share programs, grants are performance-based, terms discussed at the offer stage; 100% family premium coverage; and an effectively unlimited token budget, steered by return.

Based in Santa Monica, Los Angeles, in person, five days a week. Relocation support available for the right builder.

Selection Protocol

To ensure alignment, complete these steps in order.

Read: Culture Guide (Required)

Understanding our operating principles is essential before starting.