🎉 Launch Party! Get 60% off annual with code JOINPIGTAILS. Ends June 30 at 11:59pm.

Start free
Start free

Repo-native AI PM

Tell Pigtails what to ship.

Your repo-native AI PM scopes the work, hands it to Codex, reviews the output, and reports what is safe to merge.

  • Product memory
  • Codex delegation
  • Evidence reports
Start free View example report

pigtails / team-invites

Active delivery

Team invitations

PM mode
  1. Founder intent captured Add team invites without expanding roles.
  2. Clarifying questions Owner-only, 7-day expiry, member role for v1.
  3. Task contract drafted Scope, non-goals, tests, docs, and risks attached.
  4. Codex delegated Implementation running with product context.
  5. Review in progress Diff, tests, docs, and follow-ups checked.
agent handoff local repo 
$ pigtails delegate team-invites
spec loaded
product memory attached
codex task queued
review policy attached

The problem

AI can code. It still needs direction.

Pigtails manages the product work around coding agents: scope, context, acceptance criteria, review, docs, and follow-ups.

Stop rewriting context

Stop vague PRs

Stop trusting “done”

Stop losing decisions

Stop babysitting agents

Core product

A PM layer for Codex.

Pigtails turns product intent into scoped, delegated, reviewed delivery.

Memory

Vision, users, roadmap, constraints.

Questions

Only asks what changes the work.

Contracts

Scope, tests, docs, risks.

Delegation

Sends Codex the right context.

Review

Checks diffs, tests, docs, and evidence.

Follow-ups

Turns gaps into next tasks.

Workflow

From idea to reviewed PR.

Ask. Scope. Delegate. Review. Report. Follow up.

delivery loop
Workflow

Idea becomes reviewed PR.

  1. Ask

    Founder intent captured

    Completed
  2. Scope

    Risks and non-goals clarified

    Completed
  3. Delegate

    Codex receives the task contract

    Active
  4. Review

    Diff, tests, docs, and risks checked

    Queued
  5. Report

    Merge recommendation prepared

    Queued
  6. Follow up

    Next task queued

    Queued

FIG 0.1

Ask

Ask

Capture founder intent.

  • Founder request
  • Product goal
  • Repo context
Pigtails PM
Active request Founder intent

Ship owner-only workspace invitations for beta teams.

Goal Reduce manual onboarding Constraints Keep billing untouched Repo context Workspace settings route exists

FIG 0.2

Scope

Scope

Clarify risks and non-goals.

  • Scope decisions
  • Risk checks
  • Non-goals
Pigtails PM
Questions that change scope
  • Should invited users see billing details?
  • What happens when an invite expires?
  • Is self-serve domain joining out of scope?
Recommendation

Build invite links now. Keep domain auto-join as a non-goal.

Awaiting founder approval

FIG 0.3

Delegate

Delegate

Send Codex the task contract.

  • Acceptance criteria
  • Tests
  • Docs
Pigtails PM
Codex handoff
Codex Task contract attached Active
Context Acceptance criteria + repo rules Queued
Boundary Billing roles out of scope Planned

FIG 0.4

Review

Review

Check diff, tests, docs, and risks.

  • Diff review
  • Test evidence
  • Risk notes
Pigtails PM
Result review
Tests Unit and integration passed Diff Routes, model, permissions checked Docs Invite flow documented Risk Email delivery needs staging verification

FIG 0.5

Report

Report

Recommend what is safe to merge.

  • Evidence report
  • Merge recommendation
  • Risk notes
Pigtails PM
Ready for founder review Delivery report
RecommendationApprove after staging email check
EvidenceTests, diff, docs, risk note
Follow-upReal email provider smoke test

FIG 0.6

Follow up

Follow up

Queue the next task.

  • Follow-up queue
  • Memory update
  • Next task
Pigtails PM
Queued next Follow-up work
TaskRun staging email smoke test
MemoryEmail delivery risk recorded
NextUpdate invite docs after verification

Evidence

Evidence, not vibes.

Pigtails checks agent output before recommending merge.

review evidence
Evidence review

Ready after the evidence is checked.

Ready for founder review
Acceptance criteria 6 of 7 met
Tests Unit and integration passing
Docs Workspace guide updated
Diff risk Low, auth boundary touched
Follow-ups Staging email check required
Pigtails delivery report
Task Add team invitations
Status PR ready for founder review 
Summary:
Implemented owner-only workspace invites with pending, accepted, revoked, and expired states.

Acceptance criteria:
- Owner can invite a user by email
- Invited user can accept
- New user can create an account and join
- Non-owner cannot invite
- Revoked invite cannot be used
- Expired invite cannot be used
- Workspace settings UI updated
- Docs updated

Tests:
- Unit tests passed
- Integration tests passed
- Permission tests passed
- Email rendering requires staging verification

Files changed:
- invitation model
- workspace settings UI
- invite acceptance route
- permission checks
- docs/workspace-invites.md

Risks:
Email delivery is mocked locally. Recommend staging email test before merge.

Recommendation:
Approve after staging email check.

Product memory

Codex knows the code. Pigtails remembers the product.

Keep decisions, constraints, roadmap, testing rules, and delivery history inside the repo.

  • Vision and users

  • Roadmap and non-goals

  • Architecture constraints

  • Testing and review rules

  • Decision history

  • Follow-up work

Memory files
Repo files

Product decisions stay beside the work.

Constraints, testing policy, and follow-ups stay available for the next task.

  • vision.md
  • users.md
  • roadmap.md
  • non-goals.md
  • decision-log.md
  • testing-policy.md
  • agent-policy.md

Every delivery leaves the next task clearer.

Agent management

Manage the AI coding loop.

Pigtails does not replace Codex. It manages the work around it.

Codex first

Scope, delegate, and review Codex work today.

More agents next

Additional coding agents can plug into the same loop.

Humans stay in control

You set planning, delegation, review, and merge boundaries.

Authority

You decide how far it goes.

Strict for billing. Faster for docs. Always inside your rules.

Match autonomy to the risk of the work.

Approval controls
Authority levels

Higher autonomy is granted, not assumed.

  1. Plan only

    Draft scope and ask questions

    Allowed
  2. Delegate

    Queue coding agent work

    Allowed
  3. Open PRs

    Prepare reviewed pull requests

    Allowed
  4. Merge low-risk

    Only inside approved policies

    Locked
  5. Autonomous delivery

    Reserved for mature repo rules

    Locked

Local-first

Local-first. Repo-native.

Works in your editor, against your repo, with your approval rules.

local repo
Agent handoff

Codex gets the task contract.

$ pigtails delegate team-invites
product memory attached
task contract loaded
codex queued
review policy attached

Runs in your local development environment

Works with VS Code and Cursor

Starts with Codex

Uses your repo docs and task history

Keeps approvals under your control

Get started

Get started in your repo.

Install Pigtails, connect Codex, and delegate the first task.

Start free Get started
repo terminal
Setup

Pigtails setup commands

npm install pigtails
pigtails init
pigtails delegate "Add team invitations"

Install

Add Pigtails to your local dev environment.

Connect Codex

Use your existing authenticated Codex CLI.

Delegate

Turn a product request into reviewed implementation work.

Audience

Built for founders shipping with AI.

For builders who use coding agents but still need product judgment, review, and follow-through.

Solo founders

Ask for outcomes instead of writing implementation prompts.

Product-led engineers

Keep product intent, architecture, tests, and docs aligned while agents handle more implementation.

Small software teams

Keep agent work scoped, reviewed, and moving.

Agencies and consultants

Turn requests into scoped delivery with a clear review trail.

Capabilities

PM work your agents need.

Pigtails keeps product context attached from task to merge.

Memory

Persistent product memory

Keeps vision, users, roadmap, decisions, and constraints close to the work.

Repo understanding

Reads how the repo works

Loads architecture, tests, docs, dependencies, and delivery history.

Questions

Asks before coding

Asks only when a decision changes scope, risk, or UX.

Task contracts

Scoped work packages

Creates acceptance criteria, non-goals, tests, docs, and risk notes.

Delegation

Delegation for coding agents

Queues Codex work with the right context attached.

PR review

Checks work against the contract

Checks the contract, diff, tests, docs, and repo constraints.

Reports

Evidence-based status

Reports what changed, what passed, what is risky, and what happens next.

Follow-ups

Turns gaps into next work

Creates tasks from failed tests, partial work, review findings, and product gaps.

Repo rules

Improves the repo rules

Improves repo instructions, testing policy, fixtures, docs, and workflow rules over time.

Approval controls

Founder-controlled authority

Lets you define what Pigtails can plan, delegate, approve, or merge.

Roadmap

What ships next.

Now

Repo scan, product memory, task contracts, Codex handoff, review reports.

Next

PM inbox, task queue, follow-ups, agent integrations, GitHub sync.

Later

Multi-agent routing, release readiness, customer feedback, safer autonomy.

Pricing

Start free. Upgrade when you want unlimited primitive runs.

Free includes the full Pigtails loop with 30 primitive runs per month. Plus includes unlimited primitive runs for solo builders. Pro adds shared advanced memory and collaborative access.

Yearly pricing selected.

Free

Access your AI Product Manager

$0/mo

  • 30 primitive runs/month
  • Unlimited repos
  • Unlimited chat
  • Specifications
  • Estimations & discovery
  • Automated planning
  • Automated development
  • Dev delegation
  • Automated failure resolutions
  • Task board integrations
Start free

Plus

20% off

Unlimited access for solo builders

$8/mo

Billed annually

  • Everything in Free
  • Unlimited primitive runs
  • Unlimited specifications
  • Unlimited estimations
  • Unlimited automated planning
  • Unlimited task discovery
  • Unlimited dev orchestration
  • Unlimited dev delegation
  • Unlimited failure recovery
  • Advanced memory
Upgrade to Plus

Pro

Coming soon

Synchronized AI Product Manager for teams

Coming soon

  • Everything in Plus
  • Shared advanced memory
  • Shared team access
  • Team workspaces
  • Shared plans, specs, and delivery history
  • Team task queues
  • Team approval controls
  • Team reporting and audit trail
  • Pooled team primitive usage
  • Per-device billing
Join Pro waitlist

A primitive run is a counted execution of a core Pigtails capability. For launch, prepare is the counted primitive. Playbook automation can wrap primitives, but only primitive execution consumes usage.

Each account can have up to 5 active CLI devices. Revoke unused devices any time from your account.

Unlimited plans are subject to fair use, abuse prevention, and platform safety limits.

FAQ

Questions before you start?

The short version before you connect a repo.

Is Pigtails a coding agent?

No. Pigtails scopes the work around coding agents, reviews the output, and reports what is safe to merge.

Does Pigtails replace Codex?

No. Codex writes code. Pigtails manages the work: product context, task contract, acceptance criteria, review process, and delivery report.

How is this different from chatting with Codex or Claude?

Chat gives code-aware answers. Pigtails keeps product decisions, constraints, testing rules, and delivery history attached to each task.

Does Pigtails ask questions before coding?

Yes. Pigtails asks targeted product questions when a decision affects scope, risk, user experience, architecture, or quality. It avoids unnecessary back-and-forth.

Can Pigtails open PRs?

Pigtails is designed to prepare, delegate, review, and report on implementation work. You control whether it can create branches, open PRs, approve changes, or merge low-risk work.

Does it run locally?

Yes. Pigtails is designed as a local-first tool that works inside your development environment, with your repo, your editor, your product memory, your tools, and your approval rules.

What tools does it support?

Pigtails starts with Codex as the first supported coding agent and works with VS Code and Cursor. Claude Code, Grok Build, custom agents, and deeper task integrations are planned extensions of the same PM model.

Who is Pigtails for?

Pigtails is for founders and builders using coding agents who still need product judgment, review, and follow-through.

Ready?

Put Pigtails on the delivery loop.

Install Pigtails, connect your repo, and delegate the first task.

Start free Get started