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.
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.
claude mcp add --transport http ultipad https://ultipad.vercel.app/api/mcp --header "Authorization: Bearer YOUR_API_KEY"
From a product decision to a working build
Create a key
Generate a personal API key in Profile. It uses your existing workspace role.
Add the server
One terminal command wires Claude Code. Cursor and other MCP clients use the JSON config below.
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.

Pick your client
Claude Code
One terminal command and the 37 tools show up in your next session.
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.
{
"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.
{
"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 -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":{}}'37 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, value, and the functional spec your agent wrote.
- 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
- save_implementation_plan
- Save the agent's implementation plan to the idea's Functional Specs as a dated section — never overwrites.
- 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, and the delivery record on completion.
- add_commit_ref
- Record a git commit against the idea it implements — with diff stats, so AI-written lines of code are tracked, plus an optional fix note.
- list_commit_refs
- An idea's commit history, newest first.
- search_fix_notes
- Search how past issues were fixed — root cause, fix, gotchas — before debugging.
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.
## 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>],
functionalSpec: "<the functional spec YOU write — markdown: behaviour, edge cases, acceptance>").
The server does not draft specs for agent-created ideas. Note the ideaId.
3. set_success_metric(ideaId, name, direction, target, baseline?) — 1–3 metrics that show
whether this work succeeded. Required for every idea; you choose them (e.g. error rate
for a bug fix, adoption or latency for a feature). Skip only if the idea already has them.
4. 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.
If the commit fixes a bug, also pass a fix note so the next agent learns from it:
resolution: { problem, rootCause, fix, failedAttempts, gotchas, tags }
No secrets or customer data in fix notes.
### Before debugging — search past fixes
search_fix_notes(query: "<symptom or error text>") before investigating any bug.
### After planning — save the plan, ask before stories
save_implementation_plan(ideaId, plan) — the full plan markdown, added as a dated
section in the idea's Functional Specs (never overwrites).
After ship: record_metric_reading(...) or POST /api/metrics/readings for the metrics
you defined in GATE 1.
Do NOT create user stories on your own: ask the user; only if yes, add_user_story.
### While building (ongoing)
- add_user_story(ideaId) — only after the user asked for stories
- update_idea_details(ideaId, notes/targetOutcomes) — plans go through save_implementation_plan
- 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,
actualOutcomes: "<delivery record YOU write — what shipped, how verified, what was deferred>")
set_idea_stage(ideaId, "Done") — starts the measurement window for your metrics.
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/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; add a resolution fix note if it fixes a bug).' || 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.
- 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.
- AI
get_agent_spec
Claude Code fetched the approved spec — stories with acceptance criteria, customer evidence, and the reporting contract.
- 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).
- 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.
- AI
report_dev_progress: completed
Idea auto-moved to QA, spec status → delivered.
- 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.