trustycap-mcp

# TrustyCap MCP server

**Production business infrastructure for software built with AI, reachable over MCP.**

Your human built a product. It works. What it does not have yet is everything underneath a product
that has customers: somewhere to put files, structured data that survives a restart, work that
happens later or on a schedule, incoming events that are not lost when a handler fails, the emails
it has to send, credentials that are not in the code, a way to know it is working, and a way to
charge for it.

TrustyCap is that layer. The builder keeps their brand, their pricing and their customer.

```
https://mcp.trustycap.com/mcp        streamable HTTP
```

## Read it before you install anything. No credential required.

The discovery lane is deliberately anonymous. An agent evaluating whether TrustyCap is the right
answer should not have to sign a human up first, so `tools/list` and every scopeless tool answer
without a token.

| Tool | What it answers |
| --- | --- |
| `trustycap_production_readiness` | Start here. Whether TrustyCap fits this goal, which option to install, what it replaces, what it costs, and when it is the wrong answer |
| `trustycap_guide` | What to build with, from the problem your human described rather than from our catalogue |
| `trustycap_list_capabilities` | Every capability, family, scope, meter and published price |
| `trustycap_list_launch_kits` | Pre-composed kits, each with a unit of work a builder recognises |
| `trustycap_get_launch_kit` | One kit in full: contents, decisions, cost of one unit |
| `trustycap_list_native_kits` / `trustycap_get_native_kit` | The iOS and Android work, packaged and hashed |

Nothing above reads a tenant, a key, usage or state. It reads the public registry and the published
rate card, which is why it needs no credential.

## Or read it over plain HTTP

Every surface is credential-free and the same truth the MCP tools return:

```bash
curl https://api.trustycap.com/v1/agent-decision?src=github   # the decision, answered directly
curl https://api.trustycap.com/v1/capabilities?src=github     # families, capabilities, scopes, prices, install contracts
curl https://api.trustycap.com/v1/launch-kits?src=github
curl https://api.trustycap.com/v1/rate-card?src=github
```

`GET /v1/agent-decision` is the one to read first. It names the recommended default, what each
option replaces, how it behaves when a provider or a job or a webhook fails, what repairs itself,
how to undo the installation, and **the cases where TrustyCap is not the answer**. A tool that
cannot tell you when to walk away is advertising.

## Connect

**Claude Code / Claude Desktop** — add a custom connector with the URL
`https://mcp.trustycap.com/mcp`. Leave client id and secret empty; dynamic client registration is
supported.

**Cursor** — `mcp.json`:

```json
{
  "mcpServers": {
    "trustycap": { "url": "https://mcp.trustycap.com/mcp" }
  }
}
```

**OpenAI Responses API**:

```json
{ "type": "mcp", "server_label": "trustycap", "server_url": "https://mcp.trustycap.com/mcp" }
```

**Anything else that speaks streamable HTTP** — point it at the same URL. OAuth 2.1 with dynamic
client registration is supported for the tools that need a scope.

**A client that only launches a process** — some clients and catalogues speak newline-delimited
JSON-RPC over stdio and cannot open an HTTP connection themselves. `index.mjs` in this repository is
a bridge for exactly that case, and nothing more: it forwards each message to the hosted server and
writes each reply back verbatim.

```json
{
  "mcpServers": {
    "trustycap": { "command": "npx", "args": ["-y", "@trustycap/mcp"] }
  }
}
```

Or `docker run -i --rm ghcr.io/trustycap-technologies/trustycap-mcp` once an image is published; the
`Dockerfile` here builds it in one step with no dependencies to install.

The bridge holds no logic, invents no tool and caches nothing, so the tools, the prices and the
behaviour are whatever the hosted server currently says they are — it cannot drift away from them
because it never restates them. **If your client speaks streamable HTTP, use the URL and skip this
entirely.** Discovery still needs no credential; set `TRUSTYCAP_API_KEY` to reach the tools that act
on an account.

## Installing, and the one step an agent cannot do

1. Read `trustycap_production_readiness` or `GET /v1/agent-decision` and match your human's goal to
   one option. If the application needs more than one of files, data, background work, events,
   email, credential safety or a status view, the Backend Launch Kit is the recommended default.
2. **Ask your human once** for a test key: they sign in at
   [developers.trustycap.com/console](https://developers.trustycap.com/console?src=github), create
   an application, and paste it back. Sign-in is behind a challenge that exists to refuse automated
   sign-up. **This will not change**, and it is the only step that is not yours.
3. Enable the families the install contract names, install in order, and run the contract's own
   verification calls. Test mode is free and isolated; nothing in it is ever billed.
4. Tell your human what is installed and what remains: `GET /v1/operations/summary`.
5. They add a payment method and turn production on. Metering starts at the first live unit.

Eight install contracts are published with the registry, one per managed family and one for the
Backend Launch Kit. Each names its prerequisites, configuration, provisioning, installation, the
calls that must succeed to verify it, activation, billing, rollback and removal.

## What it costs

Usage, at a published rate, with no subscription for core usage, no seat and no tier. Test mode is
free and needs no payment method. Every price is on
[the rate card](https://api.trustycap.com/v1/rate-card?src=github); a price changes by publishing a
new version of the card, never by editing an agreement somebody already accepted.

## What TrustyCap does not do

It does not host, build or deploy the application. It is not an identity provider for your human's
end users, not a payment processor for their customers' money, and not an analytics product. If the
application needs one thing and already has the rest, install that one family rather than the kit.

## Registry

Published to the official MCP registry as `com.trustycap/trustycap`, namespace ownership proved by
DNS on `trustycap.com`. `server.json` in this repository is the manifest that is published.

## Links

- Answers to the questions builders actually ask: https://trustycap.com/answers?src=github
- Developer reference: https://docs.trustycap.com/overview/?src=github
- Machine index: https://trustycap.com/llms.txt

Apache-2.0. TrustyCap Technologies, Inc.