Caplets

Caplets

Give your agent Capabilities, not a tool wall

Turn sprawling MCP servers into focused capability cards. Your agent can start with one typed route, zoom into tools only when needed, and keep huge schemas out of the prompt until they matter.

Tool wall
215 tools
Caplets
7 cards
Code Mode
72% fewer tokens
Install & run setup Read the docs
Quick start
More setup options
  1. 01
    Install Caplets npm install -g caplets
  2. 02
    Wire up your agent caplets setup

Why Caplets

Agents do not need every tool at once.

Direct MCP flattens provider APIs into the prompt. The agent spends context reading tool names, giant schemas, and setup assumptions before it can do the work.

Caplets keeps the first surface small, then opens the exact operation path when the agent asks.

Direct MCP With Caplets

Too many tools

Every downstream operation lands in the agent's first view.

The agent starts with a named capability and opens only the route it needs.

Too much schema

Large tool definitions compete with the user's actual task for context.

Schemas stay behind inspect, search, and get_tool until they matter.

Too much setup

Every agent repeats provider wiring, OAuth, secrets, and MCP config.

One Caplets surface can be reused locally or from a remote server.

Setup

Start with the smallest useful Caplet.

caplets setup wires the agent integrations you choose. Add OSV first because it needs no auth; bring in GitHub or Sourcegraph after the discovery path feels right.

Explore more Caplets
discover cards
inspect tools
call typed
Benchmark proof

The result survived the surface cut.

Same task set, same 10/10 completion. Code Mode kept the agent focused by cutting the prompt surface instead of flattening every tool into view.

Run June 2026 with the real-world large MCP suite, openai-codex/gpt-5.5, 10 tasks, 2 runs per task, and a large no-fixture MCP stack. Read benchmark method
tasks cleared
10/10

Caplets Code Mode, progressive modes, direct MCP, and Executor.sh all completed the task set.

avg tokens
236,803

Request plus output estimate for the Code Mode run, averaged across live Pi evals.

vs vanilla
72.0% fewer

Reduction against direct vanilla MCP without giving up the completed-task result.

Mode Caplets Code Mode
Passed 10/10
Total Tokens 236,803
Tool Surface Tokens 31,166
Mode Caplets progressive + Code Mode
Passed 10/10
Total Tokens 422,861
Tool Surface Tokens 124,772
Mode Caplets progressive
Passed 10/10
Total Tokens 461,171
Tool Surface Tokens 103,776
Mode Executor.sh
Passed 10/10
Total Tokens 675,842
Tool Surface Tokens 24,570
Mode Direct vanilla MCP
Passed 10/10
Total Tokens 846,048
Tool Surface Tokens 457,818
flat tool wall 215
first screen cards 7
surface cut 79.9%

Code Mode used 72.0% fewer request + output tokens than Direct vanilla MCP and 65.0% fewer than Executor.sh. Progressive disclosure also reduced tokens while every listed mode completed 10/10 tasks.

Remote Caplets server

One auth home. Every agent gets the same tools.

Run Caplets as a small HTTP service. Provider tokens and OAuth state stay server-side; Codex, OpenCode, Pi, Claude Code, and any MCP client attach to the same capability surface.

MCP
/caplets/v1/mcp
Attach
/caplets/v1/attach
Admin
/caplets/v1/admin
Health
/caplets/v1/healthz

Client-by-client auth

Every agent carries its own provider tokens, OAuth dance, and local MCP wiring.

  • Repeat login flows
  • Copy secrets around
  • Debug each client separately

Server-held auth

One Caplets server owns provider auth; each agent attaches to the shared surface.

  • Keep tokens server-side
  • Reuse from Codex, OpenCode, Pi, Claude
  • Inspect, search, schema, and call from one place
Server owns auth GitHub, Sourcegraph, OSV
Caplets exposes inspect · search · schema · call
Agents reuse it Codex · OpenCode · Pi · Claude
Serve once 
CAPLETS_SERVER_URL=https://caplets.example.com/caplets
CAPLETS_SERVER_PASSWORD=...
caplets serve --transport http
Use remotely 
CAPLETS_REMOTE_PASSWORD=...
caplets attach --remote-url https://caplets.example.com/caplets