The capability layer for coding agents

Give your coding agent the whole stack.

Turn MCP servers, APIs, and commands into reusable Caplets your agent can use from issue to production. You choose what each agent can access.

Connect your first capability Browse shared Caplets

Whole stack means the capabilities you intentionally expose—not blanket access to every system or credential.

Supported connection model

MCP. APIs. Commands. All of it.

If your system exposes a supported interface, turn it into a Caplet—a reusable capability for coding agents. The catalog is one place to find Caplets, not the boundary of what you can connect.

Connect a backend

MCP: Wrap any supported MCP server
OpenAPI: Turn a specification into typed operations
Google Discovery: Connect Google APIs from discovery documents
GraphQL: Expose schema-driven queries and mutations
HTTP: Define focused actions for a simple endpoint
CLI: Select the repository commands an agent may run
Caplet Files: Reuse a capability definition someone has shared

CAPABILITY LAYEROne CapletScoped, inspectable, and reusable

Use it from supported agents

Codexattach
Claudeattach
OpenCodeattach
Piattach
MCP clientsattach

Client surfaces differ. Caplet definitions stay reusable, while credentials remain independently authorized.

The missing connection

Stop being your agent's human integration layer.

Your agent can change the code. You still copy the issue, inspect the dashboard, trigger the operation, and update the status.

Caplets gives it controlled capabilities across those systems while preserving the exact access, schemas, results, and errors each backend provides.

Without a capability layerWith Caplets

Without a capability layer

Work stops at the repository

The agent edits code, then waits while you carry context into issues, dashboards, CI, and deployment tools.

With Caplets

Expose the capabilities it needs so the agent can keep the task moving across authorized systems.

Without a capability layer

Every agent needs new wiring

Provider setup, auth, and integration assumptions get repeated across clients and projects.

With Caplets

Reuse the same Caplet definitions from supported agents while each host keeps access independently authorized.

Without a capability layer

Connected agents get overwhelmed

A flat wall of tools and schemas competes with the work as soon as more systems are connected.

With Caplets

Code Mode starts with named handles and opens exact schemas and operations only when the task needs them.

A reusable capability for coding agents

The agent composes the route for the task.

Each Caplet exposes one controlled capability domain. The agent selects and combines the Caplets it needs now instead of asking you to prebuild a fixed automation workflow.

Agent portability and sharing

Use one capability model across native integrations, MCP clients, and Remote Attach.

Run Caplets through native OpenCode and Pi integrations, use MCP with Codex, Claude, and other compatible clients, or connect supported Remote Attach clients. Each host independently supplies credentials and authorizes access.

Native integrations: OpenCode · Pi
MCP clients: Codex · Claude · compatible clients
Remote Attach: Supported attach clients
Capability package: The same Caplet definition

Agent portability

Reuse one capability definition across supported agent surfaces without pretending every client experience is identical.

Native OpenCode and Pi integrations
MCP for Codex, Claude, and compatible clients
Remote Attach for supported clients

Capability sharing

Keep a Caplet local, distribute it within a team, or publish it for the community without transferring authenticated authority.

Personal reuse across agents and projects
Team-distributed Caplet definitions
Public Caplets through the catalog or another source

A host authorizesOnly the selected backends

A Caplet packagesDefinition · guidance · routes

Agents compose itTask by task, not as a fixed workflow

Share capabilities, not secrets.

A shared Caplet transfers its reusable definition and operating guidance. Every receiving user or host provides and authorizes its own access.

Create a Caplet

Serve once

caplets daemon install --start
caplets remote host approve <code> --yes

Use remotely

caplets remote login <url>
caplets attach <url>

Issue to production

Let the agent carry the whole job.

Follow one illustrative route across issue tracking, source control, CI, deployment, and status instead of carrying every handoff yourself.

Every step runs only when its capability has been exposed and authorized. Caplets does not grant autonomous deployment authority.

LinearRead the issuerequirements
GitHubInspect and change codepull request
CICheck the buildverified change
DeployRelease when authorizedproduction
StatusReport the resultclosed loop

Technical evidence

Smaller surface. Same completed work.

Once the whole-stack value is clear, Code Mode proves the technical advantage: the same 10/10 task result with fewer tokens and fewer round trips than direct vanilla MCP.

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; 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 Mode10/10236,803 tokens31,166 surface

Mode: Caplets progressive + Code Mode10/10422,861 tokens124,772 surface

Mode: Caplets progressive10/10461,171 tokens103,776 surface

Mode: Executor.sh10/10675,842 tokens24,570 surface

Mode: Direct vanilla MCP10/10846,048 tokens457,818 surface

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 wall215

first screen cards7

surface cut79.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.

Connect your first capability

Get one real result. Then bring in your stack.

Set up Caplets, then run OSV first because it needs no auth. Once the agent completes that call, connect an MCP server, API, or command you already rely on.

npm install -g capletscaplets setup

Read bootstrap skilldetect -> ask -> plan -> approve

discovercards

inspecttools

calltyped

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 22+ 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 22+, 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 22+, 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"

A successful OSV call is Caplet Activation.

Once that first backend operation works, connect one capability from the stack you already use.

Connect your own backend