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.

First route the agent sees

One card opens into inspect, search, schema, and call only when needed.

osv / inspect / search_tools / get_tool / call_tool

Install & run setup Read the docs

npm install -g caplets

Requires Node 24+. Run setup from the install section next.

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

Direct MCP

Too many tools

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

With Caplets

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

Direct MCP

Too much schema

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

With Caplets

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

Direct MCP

Too much setup

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

With Caplets

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

OSV

Add OSV

Vulnerability lookups by package, purl, commit, or batch query, with no auth ceremony.

Best first install: it proves the Caplet flow before OAuth or provider secrets enter the picture.

osv /inspect /search_tools /get_tool /call_tool

OSV is public. If the trial fails, check Node 24+ and rerun caplets setup.

OSV capability commands

caplets setup
caplets install spiritledsoftware/caplets osv
codex "try using the osv caplet"

GitHub

Add GitHub

Repositories, issues, pull requests, branches, commits, and reviews behind one capability card.

This is the stress case: a valuable MCP server that is painful when every operation is exposed at once.

github /inspect /search_tools /get_tool /call_tool

If setup fails, check Node 24+, rerun caplets setup, and confirm GH_TOKEN.

GitHub capability commands

export GH_TOKEN=github_pat_...
caplets setup
caplets install spiritledsoftware/caplets github
codex "try using the github caplet"

Sourcegraph

Add Sourcegraph

Hosted code search for examples, references, and implementation patterns across repositories.

Good for search-first work: the agent asks for matches, then opens only the operations it needs.

sourcegraph /inspect /search_tools /get_tool /call_tool

If setup fails, check Node 24+, rerun caplets setup, and finish Sourcegraph OAuth login.

Sourcegraph capability commands

caplets setup
caplets install spiritledsoftware/caplets sourcegraph
caplets auth login sourcegraph
codex "try using the sourcegraph caplet"

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.

The live run rows are listed here; the linked benchmark document covers the harness, deterministic surface check, and reproduction path.

Read method & reproduce

tasks cleared: 10/10
avg tokens: 236,803
vs vanilla: 72.0% fewer

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

Mode	Passed	Total Tokens	Tool Surface Tokens
Caplets Code Mode	10/10	236,803	31,166
Caplets progressive + Code Mode	10/10	422,861	124,772
Caplets progressive	10/10	461,171	103,776
Executor.sh	10/10	675,842	24,570
Direct vanilla MCP	10/10	846,048	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

export CAPLETS_SERVER_URL=https://caplets.example.com/caplets
export CAPLETS_SERVER_PASSWORD=...
caplets serve --transport http

Use remotely

export CAPLETS_REMOTE_PASSWORD=...
caplets attach --remote-url https://caplets.example.com/caplets