Skip to main content

Optional fractional seat

Developer Experience, API and MCP Product Manager

Owns how outside developers, partners and agents reach your product: the API, the MCP server, the documentation and the first successful call.

If you hired for this full time

You would post for

  • Product Manager, AI Agents and MCP
  • Product Manager, Platform and Integrations
  • Product Manager, Developer Platform
  • Product Manager, Developer Experience

The job usually covers

  • Set the direction for the product’s agent and MCP surface and what gets exposed
  • Run the API as a product: contracts, authentication, versioning, rate limits, documentation
  • Define the MCP offering, with a security review for anything a customer can reach
  • Decide what’s built natively, what’s self-serve, and what customers and partners extend
  • Build evaluations and feedback loops so agent quality is measured
  • Govern agent access to data: identity, permissions, residency, cost
  • Treat internal product teams as customers of the platform
  • Own the developer’s path: portal, documentation, SDKs, sandbox, changelog

What we take on

We own

  • The gap index: what your interface can do that the API and MCP can’t
  • MCP tool design and tool descriptions
  • The evaluation set for the agent surface
  • Registry and directory submissions
  • Documentation for developers and for agents
  • The sandbox and the getting-started path
  • The developer changelog

We contribute, you decide

  • Which capabilities are exposed, and in what order
  • Authentication and permission model
  • Evaluation criteria
  • Documentation standards
  • SDK scope

Stays with you

  • Security and data governance sign-off
  • Model and vendor contracts
  • Internal platform team priorities

The decisions are few and they’re product decisions. Our job is to reduce "we need an AI strategy" to those decisions with the trade-offs written down, then build what was chosen. Security sign-off stays with you because you carry the liability.

What we need access to, and why

  • Core repository, read

    The gap index is built from the code and the API definitions

  • API gateway logs and usage analytics, read

    To see what agents call and where they fail

  • MCP server repository, write

    Tool design is done in code

  • Documentation repository, write

    Agents read the documentation before anything else

  • A staging tenant with realistic data

    Evaluations need it

  • Your security review process

    Every exposed capability goes through it

  • Support and sales call notes, read

    To rank the gaps by what customers ask for

How you’ll know it’s working

  • Share of core workflows reachable by API and by MCP
  • Tool-call success rate
  • Time for a new customer’s agent to make its first successful call
  • Agent traffic as a share of API traffic
  • Open items in the gap index

The first 30 days

  1. Build the gap index
  2. Frame the three or four exposure decisions for your product lead
  3. Run a baseline evaluation
  4. Close one high-value gap end to end

The same seat in each lane

Grow

What partners build against: documentation, sandbox and the path to a published app.

The Grow lane

Transform

The API and MCP surface: what outside agents can and can’t do with your product.

The Transform lane

Run

The internal MCP layer and control plane: who may use which tools.

The Run lane

How we join

  • Alongside

    When
    Someone owns the function and is stretched thin.
    What we do
    We take the operational half. They keep strategy and relationships.
    How it ends
    Scope shrinks or grows by agreement each month.
  • Interim

    When
    The role is open or not approved yet.
    What we do
    We cover the seat day to day, reporting to whoever the hire will report to.
    How it ends
    Handoff documents and a warm transition to your hire.
  • Embedded

    When
    You want one accountable person without adding headcount.
    What we do
    Your email, your Slack, your onboarding. Paid through one contract.
    How it ends
    A notice period, then the same handoff as interim.

True of every seat

Behind the seat

  • One named person holds the seat and is the only face you and your partners see.
  • Our delivery team stands behind them, so a recommendation can become a shipped build.
  • Where we bring tools of our own, or set up an integration factory, they live in your repository.
  • Agents draft and the seat holder decides. Nothing reaches a partner or a customer without a person sending it.

Access rules

  • Every access request is tied to a task. If we can’t name the task, we don’t ask.
  • Named accounts only, on your single sign-on where you have it.
  • Read access first. Write access is requested per system when a task needs it.
  • Everything is revocable in one step, and the handoff checklist includes revoking it.

Rhythm

  • A weekly written update: what moved, what’s stuck, what we need from whom.
  • One standing meeting with the person who owns the function. Everything else is async.
  • A monthly review against the measures, where scope is adjusted.
  • A decision log that you own, so the reasoning outlasts us.

Guards

  • Non-exclusive. You can hire for the role at any time.
  • A notice period in both directions.
  • Handoff documents are a deliverable.
  • Your right to take the work in-house is written in, including any code in your repository.

Tell us what’s on your plate

Tell us what’s on your plate