Product Manager (Agent-Native)

# Product & Operations Lead (Technical, Agent-Native) **Status:** Draft for review **Location:** Remote; meaningful overlap with US working hours preferred **Engagement:** [Full-time / contract-to-hire] **Reports to:** Founder ## The role We are looking for a rare kind of product leader: someone who can understand a technically ambitious product, turn an unfinished body of work into a clear operating plan, and personally drive that plan across product definition, engineering coordination, quality, release readiness, and ongoing operations. This is not a role for someone who only maintains a roadmap, runs ceremonies, or hands work to other teams. It is a hands-on, AI-forward operating role for a person who likes creating momentum: clarifying product behavior, resolving ambiguity, shaping executable work, delegating it intelligently to people and agents, following through, and getting a coherent result into users’ hands. Your first major focus will be a technically substantial, AI-enabled product with a large body of planning and implementation work already in motion. You will help turn that work into a coherent product: clear user behavior, ordered decisions, qualified releases, reliable operations, and a feedback loop that steadily improves what gets built. Over time, you may apply the same operating ability across a small portfolio of founder-led products involving AI, software infrastructure, marketplaces, interactive systems, and new forms of digital coordination. We already have people who can execute growth and marketing work. You will collaborate with them, but you are not being hired to be the primary marketer. Your responsibility is to ensure that they receive product truth, usable launch inputs, clear priorities, and credible evidence of what is ready to communicate. ## How we work: humans directing agents We are building an internal execution and coordination system comprising persistent AI agents, shared project state, and auditable work handoffs. The system can accept work, route tasks to the appropriate agent or human, maintain project context, track progress and dependencies, return artifacts for review, and preserve a record of decisions and outcomes. You will not be expected to perform knowledge work at ordinary manual speed. You will be expected to operate at **AI velocity**: using agents to research, synthesize, analyze product behavior, inspect technical context, prepare requirements and decision records, design acceptance criteria, follow up on open loops, and keep multiple workstreams moving in parallel. You will have an agent identity within our system. It can receive tasks from you, the founder, and other authorized parts of the organization; help maintain your operating context; coordinate with specialist agents; and return work for your review. Part of your job is to make this human-agent partnership effective by providing good context, defining acceptance criteria, reviewing outputs, correcting course, and ensuring that completed work creates a real result. You do not have to adopt our interface as your only working environment. If you already have a strong personal agent stack, we want to understand it. We are open to commercial agents, open-source systems, custom agents, workflow automation, or a combination of tools, provided your setup can interface cleanly with shared project state, respect authority and data boundaries, and leave consequential work visible and auditable. Personal AI productivity that creates an opaque parallel operation is not sufficient. AI velocity does not mean accepting plausible output without inspection. The human owner remains accountable for judgment, facts, quality, permissions, and the final result. ## What you will own ### Own product definition and operating clarity - Convert founder decisions, research, user feedback, and technical work into a short, ordered plan with clear owners, dependencies, and definitions of done. - Define intended product behavior clearly enough that engineering, QA, agents, and operators can distinguish a real requirement from an attractive interpretation. - Keep product intent, current implementation, technical constraints, release criteria, and user-facing claims aligned. - Break ambiguous initiatives into work that engineering, design, QA, operations, contractors, and AI agents can execute without repeated founder intervention. - Surface the few decisions that genuinely require the founder and move everything else forward independently. - Close loops. Notice when promising work is stalled, underspecified, nearly finished, or producing activity without an outcome, and push it to a useful result. ### Coordinate engineering, QA, and release readiness - Work credibly with engineers on APIs, data flows, integrations, system boundaries, failure modes, environments, and implementation tradeoffs. - Read technical plans, architecture notes, issues, pull requests, test output, and deployment evidence well enough to ask good questions and detect when product intent has been lost. - Turn product requirements into testable acceptance criteria, including edge cases, recovery behavior, observability, privacy, and security considerations. - Coordinate with QA so completion means verified user behavior and operational readiness, not merely code merged or a confident status update. - Maintain a clear release view: what is experimental, what is staging-qualified, what is production-ready, and what remains unproven. - You do not need to be the engineer implementing the system, but you must be technical enough to product-manage one without requiring the founder to translate every engineering discussion. ### Direct an AI-enabled execution system - Use your assigned agent as an active operating counterpart, not merely as a writing assistant. - Package goals into well-scoped tasks with the context, constraints, authority, evidence, and acceptance criteria that people and agents need to execute safely. - Delegate research, synthesis, drafting, analysis, coordination, and follow-up while retaining ownership of prioritization and final quality. - Decide which work should be sequential, which can run concurrently, and which requires a human checkpoint. - Review agent output critically, verify consequential claims, and turn useful artifacts into decisions, shipped work, or measurable experiments. - Keep work and decisions legible in the shared system so other people and agents do not have to reconstruct project state from private chats. - Identify missing workflows, weak handoffs, unnecessary human bottlenecks, and opportunities for safe automation. ### Connect product delivery to user learning - Define the meaningful user actions, activation events, retention signals, and product outcomes the team should measure. - Design bounded product experiments, define success in advance, and use results to determine the next product decision. - Build a reliable path from user feedback and operating evidence back into product priorities. - Provide the marketing and growth team with accurate product briefs, demonstrations, release evidence, constraints, and approved claims. - Prevent external communication from outrunning implemented and qualified product behavior. ### Run product operations without becoming a process layer - Maintain durable decision state, product requirements, dependencies, release evidence, and ownership without creating bureaucracy for its own sake. - Establish a working cadence for reviewing product state, resolving decisions, qualifying releases, and closing follow-up work. - Notice systemic friction—weak handoffs, missing ownership, unclear authority, repeated defects, stale specifications—and improve the operating system that produced it. - Keep the founder, engineering, QA, agents, and downstream teams aligned through concise product artifacts rather than unnecessary meetings. - Protect trust by clearly distinguishing what is live, what is in development, what is experimental, and what is merely proposed. ### Become a trusted product counterpart to the founder - Develop enough command of the product, market, and technical architecture to challenge assumptions and improve decisions—not merely document them. - Bring concise recommendations, evidence, tradeoffs, and a proposed next move. - Create a weekly operating view: what shipped, what changed, what was verified, what we learned, what is blocked, and what matters next. - Reduce the coordination and follow-up that depends on the founder while preserving the founder’s ownership of core vision, major economic decisions, and consequential architectural choices. ## What success looks like - Learn the product by using it, reading the existing work, reviewing agent and team activity, and speaking with the people building and promoting it. - Produce one credible view of the launch path, current bottlenecks, dependencies, and highest-leverage next moves. - Establish a working cadence for product decisions, engineering and QA coordination, release qualification, user feedback, and measurement. - Audit public messaging so it accurately distinguishes implemented, planned, and exploratory behavior. - Build a dependable working relationship with your assigned agent and use it to complete at least one meaningful initiative end to end. - Ship a coordinated product milestone with clear user behavior and durable acceptance evidence. - Make activation, use, retention, reliability, and operational quality visible enough to guide decisions. - Improve the quality, pace, and accountability of product definition, delivery, and release qualification. - Give the existing marketing and growth team a dependable stream of accurate product inputs without becoming their day-to-day manager. - Convert major open work into an actively managed plan with fewer stalled or ownerless items. - Demonstrably reduce the founder’s day-to-day execution burden without hiding state or lowering quality. ## The person we are looking for You are likely a strong fit if: - You have led a zero-to-one product or a major product initiative and can point to what you personally made happen. - You combine product judgment with operating intensity. You can move between strategy, a technical discussion, a requirement, a release review, an analytics question, and an operating problem without losing the thread. - You are technically fluent enough to work credibly with engineers and reason about APIs, AI systems, data flows, wallets, smart contracts, and the difference between implemented behavior and a concept. You do not need to be the engineer writing the contracts. - You can read technical artifacts, trace a user action across system boundaries, and ask for the evidence needed to determine what actually works. - You understand how product definition, engineering, quality, operations, user learning, and distribution reinforce one another. - You can manage engineers, QA contributors, operators, and agents through clear outcomes and acceptance criteria. - You communicate exceptionally well in writing and can turn a complicated body of work into a clear decision, requirement, plan, or operating brief. - You are direct, low-ego, resourceful, and persistent. You know when to challenge, when to decide, and when to get the work done. - You already use AI agents as part of a serious operating practice—not merely for occasional copy generation or chat. - You can explain how you delegate, supply context, preserve state, review outputs, measure quality, recover from failure, and decide when a human must remain in the loop. - You value durable task state, explicit ownership, traceable decisions, and clear approval boundaries. Experience in AI products, developer tools, technically complex consumer products, marketplaces, financial infrastructure, or multi-system integrations is valuable. An operations-oriented product leader can succeed here if they possess real technical fluency and strong product judgment. ## This role is probably not for you if - Your model of product management is primarily meetings, ticket administration, and status reporting. - You want a large team or established process before you can produce results. - You treat technical detail as somebody else’s concern. - You cannot turn an ambiguous product discussion into testable behavior and an ordered delivery plan. - You accept “the code is merged” as proof that a feature is usable and complete. - You optimize for the appearance of activity rather than shipped work, user evidence, and closed loops. - You primarily use AI as a chatbot, resist delegating meaningful work to agents, or regard review and verification as optional. - You prefer keeping tasks and agent activity in a private workflow that the rest of the organization cannot inspect or coordinate with. ## Scope and decision rights You will have broad authority to organize the product operating cadence, clarify and sequence approved work, coordinate qualification, improve handoffs, and propose product decisions. You may delegate work within the approved scope to your assigned agent and the internal agent network. Agent delegation does not expand your authority: external communications, spending, production changes, access to sensitive data, token or reward commitments, and other consequential actions remain subject to the same approval gates whether initiated by a human or an agent. The founder retains final authority over company direction, core product vision, major economic design, material spending, production releases, legal or regulatory commitments, token or chain decisions, and public promises with substantial reputational risk. ## How to apply Send us: 1. A short note explaining why this combination of product judgment, technical fluency, operations, and hands-on execution fits you. 2. Two examples of product work you personally drove from ambiguity to verified user behavior or a measurable result. Be specific about your role, constraints, decisions, technical context, and outcome. 3. One example of something you wrote or produced: a product brief, requirements document, decision record, release plan, acceptance matrix, operating memo, or similar artifact. 4. A description of the AI agents you currently use. Name the products, models, frameworks, custom agents, automations, or orchestration tools where possible. 5. Walk us through one real agentic workflow you operate: what triggers it, what you delegate, what context and tools the agent receives, how state persists, where approval gates sit, and how you decide the work is actually complete. 6. Describe one time an agent produced a plausible but wrong result, lost context, overreached, or failed mid-task. How did you detect it, recover, and change the workflow afterward? 7. Tell us what you deliberately do **not** delegate to agents and why. 8. Your location, working hours, availability, and preferred engagement model. We care more about evidence of judgment, ownership, output, and a real agentic operating practice than pedigree or polished job titles.