Skip to main content
Caplia is an MCP server for founders to improve their own company. Point Claude Desktop, Cursor, ChatGPT, or any MCP client at the Caplia MCP server with a founder key, and the agent can read your CRI score, explain the rubric’s recommendations, and run the private deck-scoring loop - regenerating your pitch deck between scores until it clears Caplia Verified. It’s the same MCP server and the same hosts as the Venture API, but your key decides what you get: a cap_fnd_* key sees the founder toolset below, scoped to your one company.

​
What you can do

Iterate your deck to 700

“Score my deck privately, rebuild the weak slides in Canva to address the feedback, and resubmit until my CRI is at least 700.” The agent loops caplia_submit_deck_draft → caplia_get_deck_draft → publish.

Understand your score

“What’s my CRI and what’s holding it back?” The agent calls caplia_get_my_scores and walks you through each domain and recommendation.

Keep your profile current

“Update my stage to Series A and fix my website.” The agent calls caplia_update_my_company.

Manage your data room

“Upload this financial model to my data room.” The agent calls caplia_upload_document - which also unlocks the financial-model points in your CRI.

​
Endpoints

Production:    https://mcp.venture.caplia.ai/
Sandbox:       https://mcp-sandbox.venture.caplia.ai/
Transport: Streamable HTTP (single POST endpoint, JSON-RPC 2.0). Protocol version 2024-11-05.
The Founder API is live in production. Use the sandbox host with a cap_fnd_test_* key to test; the deck-loop tools need a write-scoped key.

​
Authentication

Bearer-token, same model as the REST API. The cap_fnd_* prefix is what makes the founder toolset appear: 
Authorization: Bearer cap_fnd_live_<32 chars>   # production
Authorization: Bearer cap_fnd_test_<32 chars>   # sandbox
See Authentication for the company-scoped key model and how to get one.

​
Tools

11 founder tools, scoped to your own company. They appear automatically when you connect with a cap_fnd_* key (an investor key sees the venture toolset instead).

​
Read tools (require read scope)

ToolWhat an agent asks for it
caplia_get_my_company”What does Caplia have on record for my company?”
caplia_get_my_scores”What’s my CRI score and what should I fix?”
caplia_get_my_metrics”What traction metrics do investors see for me?”
caplia_list_my_documents”What’s in my data room?”
caplia_get_document_url”Download my current pitch deck.”
caplia_list_deck_drafts”Show me the CRI across all my deck drafts.”
caplia_get_deck_draft”What did my latest draft score?”

​
Write tools (require write scope)

ToolWhat an agent asks for it
caplia_update_my_company”Update my company stage and website.”
caplia_upload_document”Add this financial model to my data room.”
caplia_submit_deck_draft”Score this deck privately.”
caplia_publish_deck_draft”Publish the winning draft as my live deck.”
Every tool resolves your company from the key - there are no company ids to pass, and the agent can’t touch any company but yours.

​
Connect your AI assistant

Connect once, then drive the whole deck loop in plain English. First, get three things ready:
1

Get a founder key

Mint a cap_fnd_* key in the founder portal (see Authentication). Give it the write scope so the assistant can submit and publish decks. Use a cap_fnd_test_* key to test against sandbox, or cap_fnd_live_* for your real company.
2

Note the server URL

Sandbox (today): https://mcp-sandbox.venture.caplia.ai/. Production (at launch): https://mcp.venture.caplia.ai/. The examples below use the sandbox.
3

Install Node.js — only if you use Claude Desktop

Claude Desktop reaches the server through a small helper (npx mcp-remote) that needs Node.js (the LTS installer). Claude Code and Codex don’t need it - skip this step for those.
Now set up your assistant:
The simplest option if you don’t live in a terminal.
  1. Open (or create) your Claude config file:
    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
    • Windows: %APPDATA%\Claude\claude_desktop_config.json
  2. Paste this, with your key in place of cap_fnd_test_YOUR_KEY:
{
  "mcpServers": {
    "caplia": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp-sandbox.venture.caplia.ai/",
        "--header",
        "Authorization: Bearer cap_fnd_test_YOUR_KEY"
      ]
    }
  }
}
  1. Quit Claude Desktop completely and reopen it (closing the window isn’t enough).
  2. Open a new chat and click the tools (plug) icon - the caplia tools should be listed. Ask “What’s my CRI on Caplia?” to confirm.
Requires Node.js (step 3 above). At launch, swap the URL to https://mcp.venture.caplia.ai/ and use your cap_fnd_live_* key.

​
Run the deck loop from your assistant

Once connected - in Claude, Codex, or any MCP client - drive the whole deck loop in natural language. Give the assistant access to a deck tool (Canva, Google Slides, a local generator) and ask:
“Submit my pitch deck seed-deck.pdf to Caplia for private scoring. Read the recommendations, rebuild the weak slides to address them, and resubmit. Keep iterating until my CRI is at least 700, then show me the best draft before we publish it.”
The agent submits drafts, reads the private CRI and recommendations, regenerates the deck, and resubmits - looping until you’re Verified. Drafts stay private the whole time; only caplia_publish_deck_draft makes a public update.

​
Quick test from the terminal

# Liveness + protocol check (no auth) — a real MCP server answers `initialize`
curl -X POST https://mcp-sandbox.venture.caplia.ai/ \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'

# List the founder tools (send your founder key so the founder toolset is advertised)
curl -X POST https://mcp-sandbox.venture.caplia.ai/ \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer cap_fnd_test_..." \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

# Read your scores
curl -X POST https://mcp-sandbox.venture.caplia.ai/ \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer cap_fnd_test_..." \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"caplia_get_my_scores","arguments":{}}}'

​
Limitations

  • Sandbox for testing. Rehearse against the -sandbox host with a cap_fnd_test_* key before going live.
  • No streaming responses. Each tool call is a single request-response; deck scoring is polled via caplia_get_deck_draft.
  • 50 MB max per deck or document, base64-encoded.
  • JSON output only. Each tool returns raw JSON from the REST endpoint as a text content block.