Ultipad

TL;DR

UltiPad is a product management platform built for the AI-coding era. It connects customer feedback, product decisions, roadmaps, and acceptance criteria to AI coding agents — Claude Code, Cursor, Codex — through a native MCP (Model Context Protocol) server. Where every other PM tool stops at delivery, UltiPad closes the full loop: agents read the approved spec before writing a line, then write back their progress, commit references, and completed stories when done. Strategy and delivery finally share a single memory.

Market Scope

The Opportunity

The global project and product management software market is valued at ~$6B in 2024 and growing at ~13% CAGR. But the real inflection point is the AI developer tooling wave layered on top: GitHub Copilot, Cursor, Claude Code, and Codex now collectively serve millions of developers — and none of them have product context baked in.

The Tailwind

• MCP adoption is accelerating. Anthropic's Model Context Protocol became a de-facto standard for agent-to-tool connections in 2025. Every major coding assistant now supports it. UltiPad is positioned as the canonical product management MCP server.
• AI-assisted development is mainstream. Surveys in 2025 showed >60% of professional developers use AI coding tools daily. The bottleneck has shifted from "can the agent write code?" to "does the agent know what to build?"
• PM tooling is fragmented. Teams cobble together Notion for specs, Jira for tickets, Productboard for feedback, and Slack for decisions. None connect to agents. None close the loop from customer signal to shipped commit.

Target Market

The Problem

AI agents build without context — and PMs have no visibility when they do.

Product teams today live with two compounding failures:

1. Agents are flying blind. When a developer prompts Claude Code or Cursor to "build the onboarding flow," the agent has no access to the customer feedback that motivated it, the product objective it serves, the acceptance criteria the PM wrote, or the decisions that were already made and rejected. It guesses from the code alone. The result is technically correct but strategically wrong — and the PM finds out in review.

2. The strategy-to-delivery chain is broken. Customer feedback lives in Intercom or Notion. Product decisions live in Productboard or Confluence. Tickets live in Jira or Linear. Git commits live in GitHub. None of these systems talk to each other, and none of them talk to AI coding agents. Every handoff is a lossy copy-paste. Context evaporates. By the time a feature ships, nobody can trace it back to the customer signal that justified it.

The symptoms teams feel:

• "Why did we build this?" conversations in sprint retros
• Agents implementing the wrong version of a spec because they read an outdated comment
• PMs spending hours writing the same requirement twice — once for humans, once for the AI
• No way to measure whether AI-coded features actually addressed customer needs
• Zero attribution: which commits came from AI? Which ideas drove the most agent output?

Personas

Primary — The AI-Era Product Manager

"I own the roadmap. I don't own the agents. But I'm the one asked why what shipped doesn't match what customers asked for."

• Who: PM or Head of Product at a 10–80 person software company
• Context: Team uses Claude Code, Cursor, or Codex for 40–70% of implementation work
• Pain: Writes specs in Notion, tickets in Linear, and then re-explains everything to the agent in Slack threads. Has no visibility into what the agent actually built or which commits map to which ideas.
• Goal: Product decisions made once, respected by humans and agents alike. A clear line from customer evidence → approved spec → shipped commit.
• Frustration quote: "I wrote the requirement. The agent read the code. It built something adjacent. We shipped it anyway."

Secondary — The Engineering Lead Who Also PMs

"We move fast. I'm writing the spec and reviewing the PR. I need the agent to already know what we're building."

• Who: Tech lead or CTO at a seed/Series A startup, wearing both product and engineering hats
• Context: Small team, high velocity, agents doing most of the scaffolding and feature work
• Pain: Context lives in their head. When they prompt the agent, they re-explain the product strategy every time. Nothing accumulates.
• Goal: One place where product intent lives that the agent can read without being told.

Tertiary — The VP Engineering Tracking AI Output

"How much of our code is AI-written? Are agents building against spec or going rogue?"

• Who: VP Eng or CTO at a 50–200 person company rolling out AI-assisted development at scale
• Pain: No tooling to measure AI output quality, no way to attribute commits to product decisions, no audit trail when something ships wrong.
• Goal: Governance and measurement over AI coding activity without slowing teams down.

The Solution

UltiPad is the product intelligence layer that sits between customer signals and AI coding agents. It does three things no other tool does together:

1. Capture — Close the feedback loop

Customer feedback flows in (from CRM, email, support, or manual entry), gets triaged, scored for impact/effort/confidence, and linked as evidence to the ideas it supports. Every idea has a traceable chain: customer said this → we prioritised it because of that → here's the spec → here's the commit.

2. Decide — One place for product decisions

• Objectives & Key Results link initiatives to company strategy
• Now/Next/Later roadmaps visible to stakeholders via shareable portals
• Idea workflow moves from unsorted → backlog → spec → in progress → done
• Agent Spec — a human-approved implementation brief that agents pull before they write code
• Custom scoring with weighted formulas for prioritisation

3. Deliver — Agents work with product context, not against it

UltiPad's 27-tool MCP server gives any MCP-compatible agent (Claude Code, Cursor, Codex, Claude Desktop) direct read/write access to the full product graph:

• get_product_overview — strategy, OKRs, roadmap in one call
• search_ideas / get_agent_spec — find the right spec before coding
• add_user_story / update_idea_details — agents document decisions as they build
• add_commit_ref — every commit linked to its idea, with diff stats, so AI-written lines are tracked
• report_dev_progress — agent marks work started/completed; idea stage moves automatically

The agent starts a session, reads the product context, builds against the approved spec, and closes the loop when it commits. The PM sees it happen in real time.

Why Now

Three forces converged in 2025 that make this the right moment — and make waiting costly:

MCP became the universal agent interface

Anthropic open-sourced the Model Context Protocol in late 2024. By mid-2025, Claude Code, Cursor, Codex, Claude Desktop, and a growing set of IDEs all support it natively. This created a standard pipe between AI agents and external tools — one that didn't exist 18 months ago. UltiPad was built on this pipe from day one, not retrofitted onto it.

AI-assisted development crossed the mainstream threshold

AI coding tools went from "curious early adopters" to "default workflow" for professional engineers in 2024–25. Teams are now measuring what percentage of their codebase is AI-generated. The question has shifted from "should we use AI agents?" to "how do we manage what AI agents build?" That's a product management question.

Existing PM tools weren't built for this

Productboard, Jira, Linear, and Notion were designed when developers were the only readers of a spec. None of them have MCP servers. None of them have write-back from agents. None of them track which commits came from AI. They're great tools for human-to-human handoffs. They're blind to human-to-agent handoffs. The window to establish a new category leader is open now — before the incumbents bolt on half-solutions.

The cost of the status quo is compounding

Every month a team ships AI-coded features without product context is a month of untraced decisions, misaligned output, and lost customer signal. The longer the gap, the harder it is to retrofit accountability. Teams that adopt UltiPad now build the habit and the data asset simultaneously.

Differentiation

UltiPad doesn't compete on features PMs already have. It wins on the one layer nobody else built.

The moat: three things no competitor has combined

Agent Spec (build contract). A PM drafts the implementation spec inside UltiPad; an AI can draft a first version in seconds. A human approves it. Only then does the agent pull it via get_agent_spec. This is the first human-in-the-loop gate between product intent and AI execution.

Write-back MCP. Most tools expose read APIs. UltiPad's MCP is bidirectional: agents read context AND write progress, commits, stories, and stage moves back. The PM's board updates as the agent builds. No webhook setup, no integration tax.

AI Dev Cost tracking. Every add_commit_ref call records additions, deletions, and files changed alongside the agent model that made them. UltiPad's Reports tab shows exactly which ideas drove the most AI-generated code — and what it cost in compute. No other product management tool has this.

Product Architecture

UltiPad is a Next.js 15 full-stack app deployed on Vercel, live at ultipad.vercel.app. Version 0.2.

Core Modules

Tech Stack

• Framework: Next.js 15 (App Router, Server Actions)
• Database: MongoDB (Mongoose)
• Auth: Session-based (custom, httpOnly cookies)
• Storage: Vercel Blob
• AI: Anthropic Claude API (spec drafting, CoPilot, story generation)
• Charts: ApexCharts (dark-themed)
• Design system: Tailwind CSS, dark-first (#050607 base, emerald primary, violet AI-only)
• MCP transport: HTTP Streaming (stateless, token-authenticated)
• Testing: Vitest (unit), Playwright (E2E)
• Deploy: Vercel (CLI-only, vercel --prod)

Traction & Roadmap

What's shipped (as of September 2026)

UltiPad is live in production and used to manage its own development — every feature is built by the product itself (dogfood-first).

Shipped in the last 6 months:

• CoPilot skills library with slash-command interface
• Agent knowledge grounding + product-scoped doc sources
• Custom fields with weighted priority formula
• Idea types + convert-feedback-to-idea flow
• Bulk stage / product / initiative / owner mapping
• Sortable stage column
• Product-tab scoping for ideas and feedback views
• MCP attachment tools (full 27-tool suite)
• API-key multipart file uploads
• Product-level access control (membership scoping, full read/write enforcement, admin UI)
• Dark/light/system theme toggle
• GitHub webhook: auto-links commits to ideas on push

Roadmap (Now → Next → Later)

Now

• AI Job Infrastructure — cron + resumable batch-slice jobs for async AI tasks
• Spec-to-Agent Handoff (ADLC) — full agent development lifecycle via MCP: get_agent_spec, report_dev_progress, auto-stage moves

Next

• Discovery Copilot — transcript + support thread → automatic feedback triage and tagging
• Feedback Intelligence — clustering, sentiment analysis, weekly digest for PMs

Later

• AI Evals for Product Teams — measure whether AI-built features actually moved the metrics they were meant to (Langfuse-lite, the flagship differentiator)

Build philosophy

Every feature is built using UltiPad's own MCP workflow: idea created, agent spec approved, Claude Code builds against the spec, commits linked back. The product is its own proof of concept.

Business Model

Current

Free during beta. UltiPad is onboarding teams by waitlist to build usage data, validate the MCP workflow, and refine the core loop. No paywalls during this phase.

Planned monetisation

Why this model works

• Maker-seat pricing aligns cost with value: teams pay based on the PMs and tech leads who govern decisions, not every viewer.
• MCP usage as the expansion signal: as teams add more agents and products, the natural pull is upward. No upsell theatre — usage drives it.
• Complementary to Jira/Linear: UltiPad is the decision layer, not the delivery tracker. Most teams keep their existing tools and add UltiPad in front. This reduces switching friction and accelerates adoption.
• Data asset compounds over time: the longer a team uses UltiPad, the richer their product knowledge graph becomes. Churn is expensive for them — stickiness is structural.

Revenue adjacencies

• AI Evals module (roadmap → Later): outcome measurement as a premium feature — did the AI-built feature actually improve the metric it was meant to?
• MCP marketplace listing: distribution via Claude Desktop, Cursor, and Codex plugin directories as MCP ecosystems mature.
• Team analytics API: enterprise export of AI Dev Cost + delivery data for internal BI tools.