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 35 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":{}}'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.
## 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/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.
- 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.