MCP · Claude Code · Codex · Cursor

The product context layer for your AI agent.

Connect your coding agent to UltiPad and it can find the customer evidence, roadmap decision, and acceptance criteria behind the feature it is about to build.

codex · ultipad MCP

you Ship the team onboarding flow we discussed.

→ ultipad.get_product_overview()

Objective found: Make every new team successful in week one

→ ultipad.search_ideas("team onboarding")

12 matching signals · 2 roadmap initiatives · acceptance criteria ready

→ ultipad.add_user_story()

Context linked. I’ll update the product record when the work ships.

Quick connect

Connect in under a minute.

Create a key once, use the client you already work in, and your agent gets the whole product loop as structured tools.

Your key is shown once and stored hashed. Reviewer keys are read-only.

Terminal · Claude Code
claude mcp add --transport http ultipad https://ultipad.vercel.app/api/mcp --header "Authorization: Bearer YOUR_API_KEY"
Streamable HTTPPer-user API keys35 product toolsClaude Code + Cursor + Codex

From a product decision to a working build

01

Create a key

Generate a personal API key in Profile. It uses your existing workspace role.

02

Add the server

One terminal command wires Claude Code. Cursor and other MCP clients use the JSON config below.

03

Build with context

Your agent reads the roadmap before it writes code and keeps the product record current after.

Not a mock-up

A real Claude Code session publishing a plan to UltiPad

The agent finished planning, then called the ultipad MCP to create five roadmap initiatives and verify them on the live roadmap. This is how UltiPad builds UltiPad.

claude code · ultipad MCP · live session
Claude Code session calling the ultipad MCP: plan approved, main product UltiPad found, creating 5 initiatives

Pick your client

Claude Code

One terminal command and the 35 tools show up in your next session.

Terminal
claude mcp add --transport http ultipad https://ultipad.vercel.app/api/mcp --header "Authorization: Bearer YOUR_API_KEY"

Claude Desktop

Add the server to your Claude Desktop MCP configuration file.

claude_desktop_config.json
{
  "mcpServers": {
    "ultipad": {
      "type": "http",
      "url": "https://ultipad.vercel.app/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Cursor and other MCP clients

Any streamable-HTTP MCP client works; the config shape is the same.

mcp.json
{
  "mcpServers": {
    "ultipad": {
      "type": "http",
      "url": "https://ultipad.vercel.app/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Raw HTTP API

It is plain JSON-RPC 2.0 over HTTP. Initialize, then call tools/list and tools/call.

curl
curl -X POST https://ultipad.vercel.app/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}'

35 tools, the whole product loop

Everything an agent needs to read strategy and write progress back. Write tools require an editor or admin key; reviewer keys are read-only.

Strategy

get_product_overview
Full context pack: canvas, objectives with key results, roadmap counts.
list_objectives
Objectives and key results, scoped by product or portfolio.
create_objective
Create an objective with optional key results.
link_initiative_to_key_result
Mark an initiative as contributing to a key result. Idempotent.

Roadmap

list_initiatives
List roadmap initiatives, optionally filtered by view.
get_roadmap
All initiatives in now/next/later columns, optionally per product.
create_initiative
Create a roadmap initiative. Column defaults to now.
link_idea_to_initiative
Attach an existing idea to a roadmap initiative.

Ideas

search_ideas
Keyword search across ideas in every state.
get_idea
Full detail for one idea by ID or display number.
list_ideas
List ideas, optionally filtered by state.
create_idea
Capture a new idea with problem and value.
update_idea_state
Move an idea between unsorted, backlog, and archived.
update_idea_details
Document functional specs, notes, and target outcomes on an idea.
update_idea_scores
Set impact, effort, and confidence so the idea lands on the priority chart.
set_idea_stage
Move an idea to a workflow stage by name.
list_workflow_stages
The account's idea workflow stages, in order.
add_user_story
Add a user story with acceptance criteria to an idea.
push_idea_to_github
Push an idea to GitHub as an issue with its stories as a checklist.

Feedback

search_feedback
Keyword search across feedback items.
get_feedback
Full detail for one feedback item by display number.
create_feedback
Log feedback from a contact email; the contact is found or created.
link_feedback_to_idea
Connect feedback to the idea it supports as evidence.
update_feedback_state
Move feedback between inbox, reviewed, and archived.
add_comment
Comment on an idea — shown with an AI badge in the Comments panel.

Delivery

get_agent_spec
The approved implementation spec as agent-ready markdown.
draft_agent_spec
AI-draft the implementation spec; a human approves before agents build.
report_dev_progress
Agent write-back: comment, stage move, spec status, completed stories.
add_commit_ref
Record a git commit against the idea it implements — with diff stats, so AI-written lines of code are tracked.
list_commit_refs
An idea's commit history, newest first.

Files

add_attachment
Attach a file (base64, ≤4 MB) to an idea, feedback item, or initiative. Large files: use the direct upload endpoint instead.
list_attachments
List the files attached to an entity.

Reports & products

get_reports_summary
Aggregated report data: ideas, feedback, okr, or efficiency tabs.
list_products
All products in the workspace.
whoami
Key owner, role, and resolved product scope in one call.

Make it part of the loop

Paste this into your repo's CLAUDE.md (or your agent's rules file) and your assistant reads the roadmap before it builds, then writes shipped work back — including AI dev cost tracking per idea.

Rules snippet (CLAUDE.md / agent rules)
## UltiPad product sync (MCP: ultipad)

### One-time setup — resolve your product
list_products → pick the product for this repo. Record it here and reuse for every call:
  This repo → product: <NAME>, productId: <ID>

### GATE 1 — STOP before writing any code or editing any file
Do these steps first, every time:
1. search_ideas — find if an idea exists for this work.
2. If no match: create_idea(title, description, ideaType, productIds:[<ID>]). Note the ideaId.
3. report_dev_progress(ideaId, "started", agentModel, sessionId)
If idea has an approved spec: get_agent_spec(ideaId) and implement against it.

### GATE 2 — immediately after every git commit (before anything else)
```
git show --shortstat <sha>   # get additions/deletions/filesChanged
add_commit_ref(ideaId, sha, message, additions, deletions, filesChanged,
               agentModel="<your-model-id>", sessionId="<session-id>")
```
One call per commit. Do not batch. Do not defer.

### While building (ongoing)
- add_user_story(ideaId) — acceptance criteria as they firm up
- update_idea_details(ideaId, functionalSpecs/notes/targetOutcomes)
- update_idea_scores(ideaId, impact, effort, confidence) — scale: 0 1 2 3 5 8 13 20 40 100
- get_product_overview + get_roadmap — read strategy before major decisions

### GATE 3 — after shipping
report_dev_progress(ideaId, "completed", agentModel, sessionId)
set_idea_stage(ideaId, "Done")
update_idea_state(ideaId, "approved") if user approved the work.
Never write to another product's roadmap.

Make commit tracking deterministic: the git webhook (Settings → Configuration) links pushed commits that mention an idea number automatically — and this optional Claude Code hook reminds the agent after every local commit, so nothing depends on the model remembering.

Claude Code post-commit hook (.claude/settings.json)
// .claude/settings.json (in your repo) — deterministic reminder so the agent
// never forgets to record commits against UltiPad ideas.
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.command // empty' | grep -q 'git commit' && echo 'REMINDER: record this commit on its UltiPad idea via the ultipad MCP add_commit_ref tool (sha + message + webUrl + additions/deletions from git show --shortstat).' || true"
          }
        ]
      }
    ]
  }
}

This actually happened

The first idea shipped end-to-end through its own product's agent loop

UltiPad idea #4 was specified, handed off, implemented, tracked, QA'd, and re-delivered by a coding agent over this MCP server \u2014 every comment, stage move, and commit below was written by the machine, inside UltiPad, with the PM only approving the spec and testing the result. That is ADLC: the agentic development lifecycle, live.

  1. PM

    Approved the spec

    Idea #4 “AI-powered idea scoring assistant”: AI drafted the spec from the idea, its feedback, and user stories; the PM edited and hit Approve for handoff.

  2. AI

    get_agent_spec

    Claude Code fetched the approved spec — stories with acceptance criteria, customer evidence, and the reporting contract.

  3. AI

    report_dev_progress: started

    Comment posted, idea auto-moved to In Progress — including a flagged spec deviation (RICE in the draft vs the product’s real Impact/Effort/Confidence model).

  4. AI

    Implemented + add_commit_ref

    ✨ Suggest scores shipped per spec — per-dimension accept, nothing written without explicit action — and the commit landed on the idea’s Commits tab.

  5. AI

    report_dev_progress: completed

    Idea auto-moved to QA, spec status → delivered.

  6. PM

    QA found a bug

    Accepted scores didn’t refresh on screen. The agent fixed it, recorded the fix commit, and the loop correctly moved the idea back to In Progress — then re-delivered to QA.

One human step in the whole loop: dragging the idea to Done after testing it. Exactly where the human belongs.

Good to know

  • Rate limit: 60 requests per minute per key.
  • API keys are shown once at creation and stored hashed. Create them in Profile, under API Keys.
  • A key acts as you: it carries your user identity and workspace role.
  • Reviewer-role keys can read everything but cannot call write tools.