# Gloam (npm · @gloamtrade/mcp)

Private stablecoin payments for people and AI agents on mainnet, hosted or local with limits.

- Trust score: 49/100 (low)
- Change this week: −20
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `www.gloam.trade`: 84/100, [markdown](https://verifymcp.io/servers/cryptoduke01-gloam/www.md), [page](https://verifymcp.io/servers/cryptoduke01-gloam/www)
- npm · `@gloamtrade/mcp`: 49/100 (this document), [markdown](https://verifymcp.io/servers/cryptoduke01-gloam/gloamtrade-mcp.md), [page](https://verifymcp.io/servers/cryptoduke01-gloam/gloamtrade-mcp)

## Channel facts

- Registry: `npm`
- Package: `@gloamtrade/mcp`
- Version: `0.8.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 13/100
  - Malware scan not yet available for this package.
  - Known CVEs could not be checked: the version this server declares is not published in its registry.
  - No install/post-install scripts declared.
  - Dependency health could not be checked: the version this server declares is not published in its registry.
- **Provenance & Transparency**: 48/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 60/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3706 tokens (~218/item across 17 items; 17 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 56/100
  - Stability check failed: the tool surface changed between 0.2.0 and 0.8.0: 3 tool removals, 0 breaking changes, 3 additions.
- **Tool Coverage**: 99/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 96% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 5 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "gloam_execute_private_swap" implies "execute" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 17 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Gloam MCP server?

Gloam runs locally as an npm package, launched with npx -y @gloamtrade/mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add cryptoduke01-gloam -- npx -y @gloamtrade/mcp
```

### Cursor

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

### VS Code

```json
{
  "servers": {
    "cryptoduke01-gloam": {
      "command": "npx",
      "args": [
        "-y",
        "@gloamtrade/mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add cryptoduke01-gloam -- npx -y @gloamtrade/mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "cryptoduke01-gloam": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@gloamtrade/mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add cryptoduke01-gloam --command npx --arg -y --arg @gloamtrade/mcp
```

### Hermes

```yaml
mcp_servers:
  cryptoduke01-gloam:
    command: "npx"
    args: ["-y", "@gloamtrade/mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "cryptoduke01-gloam": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@gloamtrade/mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add cryptoduke01-gloam -t stdio -c npx -a -y @gloamtrade/mcp
```

### Other

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

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 49, −20)

- [security regression] Known CVEs: fail → unverified
- [security regression] Malware scan: pass → unverified
- [security improvement] CVE-2026-118764 no longer affects this package
- [functional regression] Dependency health: 0.84 → unverified
- [functional] Package version: 0.7.0 → 0.8.0
- [functional] Package version: 0.7.0 → 0.7.2

### 2026-11-04 (score 69, +1)

No change was recorded against any check on this day. Stability & Change Management went from 49 to 52.

### 2026-11-03 (score 68, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-02 (score 53, −17)

- [security regression] Malware scan: pass → unverified
- [security regression] Stability: 0.60 → fail
- [functional regression] Schema quality: 151 → 205
- [functional improvement] Tool coverage: 89% → 96%
- [functional] Package version: 0.3.0 → 0.7.0

### 2026-10-31 (score 70, +1)

- [security regression] CVE-2026-118764 affects this package: high

### 2026-10-30 (score 69, 0)

- [functional] Package version: 0.2.0 → 0.3.0

### 2026-10-29 (score 69, +1)

No change was recorded against any check on this day. Stability & Change Management went from 47 to 50. That category is still filling its 30-day observation window: 14 days of observed history at the previous scan, 15 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-27 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 40 to 43. That category is still filling its 30-day observation window: 12 days of observed history at the previous scan, 13 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (17)

### `gloam_info` (~34 tokens)

About Gloam

What Gloam is, which networks it runs on, and what an agent can do with it. Call this first.

### `gloam_privacy_status` (~48 tokens)

Privacy status

Honest, current privacy posture: what is live, what is not, and how strong the anonymity set is. Agents should check this before assuming what a payment or a swap keeps private.

### `gloam_swap_quote` (~373 tokens)

Quote a private swap

Read only. Price a private swap of one note's value from one asset into another on a Gloam network, with everything that would stop it: price impact and peg on Base and Ethereum, the vault's limits (the refund note must fit, the vault must take what you receive), the vault's cash-out fee read live, and where gas is dear the relay's smallest swap. A private swap hides who swapped; the tokens and the amounts are public. Swap with gloam_execute_private_swap.

Input parameters:

- `amount` (number): How much to swap, in the asset's units (e.g. 25 for 25 USDC).
- `from` (string): What you pay: a symbol ("USDG", "USDC", "ETH") or a 0x token address. Left out with a note handle: the note's asset.
- `maxImpactBps` (integer): The most price impact to accept, in basis points (100 = 1%). It can only lower the owner's cap (GLOAM_SWAP_MAX_IMPACT_BPS, 200 unless set), never raise it.
- `network` (string): Which network to swap on: "robinhood-mainnet", "tempo-mainnet", "base-mainnet", "ethereum-mainnet", "robinhood", "tempo", "base", "ethereum". The -mainnet ones are the mainnets (beta deposit limits);…
- `note` (string): A note handle (gloam_list_notes): quote swapping its whole value.
- `to` (string, required): What you receive: a symbol or a 0x token address ("ETH" is native ETH).

### `gloam_execute_private_swap` (~449 tokens)

Execute a private swap

REAL execution. Swap one note's value from one asset into another, privately: proves locally (the swapped note's unshield to a one-time escrow, the new note, and a refund note) and sends it through the Gloam relay, never from this server's wallet. Who swapped stays private; the tokens and the amounts are public. A swap spends one whole note: with an amount below a note's value, the note is first split with a private send to this server's own notes. Checked first against the owner's spending limits ("swap" must be listed in the agent's tools) and everything gloam_swap_quote checks. Both new notes are kept before anything is sent; gloam_finish_swap brings back a swap whose money waits at its escrow. A swap that reverts leaves its note held: it moves whole to a fresh note right away, and nothing spends it before that.

Input parameters:

- `amount` (number): How much to swap, in the asset's units. Left out with a note handle: its whole value.
- `from` (string): What you pay: a symbol or a 0x token address. Left out with a note handle: the note's asset.
- `maxImpactBps` (integer): The most price impact to accept, in basis points (100 = 1%). It can only lower the owner's cap (GLOAM_SWAP_MAX_IMPACT_BPS, 200 unless set), never raise it.
- `network` (string): Which network to swap on: "robinhood-mainnet", "tempo-mainnet", "base-mainnet", "ethereum-mainnet", "robinhood", "tempo", "base", "ethereum". The -mainnet ones are the mainnets (beta deposit limits);…
- `note` (string): The note handle to swap from (gloam_list_notes). Left out: an exact match, else the smallest note that covers the amount.
- `to` (string, required): What you receive: a symbol or a 0x token address.

### `gloam_finish_swap` (~167 tokens)

Finish a private swap

Settle a swap this server made, by its refund note's handle (or its new note's): reads how it ended and does what is needed. When the swapped note's money waits at the swap's escrow, it brings it back as the refund note through the relay; when the refund note can't take it (the vault's fee rose, or the vault is full on routers with an exit), it sends it to a `to` address you give, which is public and goes through the owner's limits like any spend.

Input parameters:

- `note` (string, required): The swap's refund note handle (gloam_list_notes shows it), or its new note's.
- `to` (string): Only for an exit: the 0x address the waiting money goes to. Public.

### `gloam_plan_shield` (~86 tokens)

Plan a shield (deposit to private)

Describe moving funds into a private balance (shield), the first step before paying privately. To actually shield, use gloam_execute_shield.

Input parameters:

- `agentAddress` (string)
- `asset` (string): Asset to shield, e.g. USDG, USDC.e, or ETH on testnet.
- `usd` (number, required): Amount to shield, in USD.

### `gloam_execute_shield` (~374 tokens)

Execute a private shield

Deposit into a PRIVATE balance on the chosen Gloam network. Mints a note, generates the Groth16 shield proof server-side with that network's keys, and broadcasts shieldBound() (approving the ERC-20 first when the asset is a token). A mainnet vault takes only the assets it lists (this tool names them if given another), within the deposit limits it reads from the vault; direct deposits are free. The note's secret stays inside this server; the agent gets a note handle to pay from later (gloam_execute_private_pay, gloam_list_notes). Requires GLOAM_AGENT_PRIVATE_KEY; without it, returns a plan.

Input parameters:

- `amount` (number, required): Amount to shield into a private balance, in the asset's units (e.g. 25 for 25 USDC.e).
- `asset` (string): ERC-20 token address to shield; omit to use the network default (USDG on Robinhood Chain mainnet, USDC.e on Tempo mainnet, USDC on Base and Ethereum, PathUSD on Tempo testnet, native ETH on Robinhood…
- `decimals` (integer): Decimals of the asset; omit to use the asset's own (6 for the stablecoins, 18 for GLOAM and ETH).
- `network` (string): Which network to shield on: "robinhood-mainnet", "tempo-mainnet", "base-mainnet", "ethereum-mainnet", "robinhood", "tempo", "base", "ethereum". The -mainnet ones are the mainnets (beta deposit limits…

### `gloam_execute_transfer` (~106 tokens)

Execute a transfer (public)

Send test ETH publicly on Robinhood Chain TESTNET from the agent wallet, for funding while practicing. This is the PUBLIC rail (amount and recipient are visible) and testnet only. For private movement, use gloam_execute_shield and gloam_execute_private_pay. Requires GLOAM_AGENT_PRIVATE_KEY; without it, returns a plan only.

Input parameters:

- `eth` (number, required): Amount of testnet ETH to send.
- `to` (string, required): Recipient 0x address.

### `gloam_list_notes` (~156 tokens)

Private notes and balance

This server's private notes as handles, with network, asset, amount, status (unspent, pending, spent, dead when its transaction can never land, or held when its last swap reverted and it must move to a fresh note before anything spends it) and the transaction that created each one, plus the spendable private balance per asset. Never shows a secret. Pass refresh to check pending notes against the chain.

Input parameters:

- `includeSpent` (boolean): Also list spent and dead notes.
- `network` (string): Only this network.
- `refresh` (boolean): Check pending notes on chain first (read-only calls), and move each held note to a fresh note of this server's (a private send through the relay).

### `gloam_receive_tag` (~59 tokens)

This server's receive tag

The receive tag (gloamr1.…) others pay this server to. Payments sealed to it open only with the key this server keeps. Created on first use. Share it freely: it is a public key, not a secret.

### `gloam_payment_requirements` (~447 tokens)

Price a resource in private payments (x402 and MPP)

SERVER side. Build the HTTP 402 price an agent-paid resource returns, settled privately through Gloam: the amount and the payee never go public, and through the relay neither does the payer's wallet. Returns it in both dialects: x402 requirements (and their encoded form), and an MPP challenge (mpp.wwwAuthenticate, the WWW-Authenticate: Payment value for method gloam, intent charge). payTo defaults to this server's own receive tag. Check what the payer presents with gloam_verify_payment.

Input parameters:

- `amount` (number, required): Price in the asset's display units, e.g. 0.25.
- `asset` (string): Settlement token address; omit for the network default (USDG on Robinhood Chain mainnet, USDC.e on Tempo mainnet, USDC on Base and Ethereum, PathUSD on Tempo testnet, ETH on Robinhood Chain testnet).
- `assetSymbol` (string): Asset label, e.g. USDC.e; omit for the asset's own symbol.
- `decimals` (integer): Decimals of the settlement asset; omit for the asset's own (6 for the stablecoins).
- `expiresInSeconds` (integer): How long the MPP challenge stays valid. Leave room to prove and confirm a payment.
- `network` (string): Which Gloam network the payer settles on: "robinhood-mainnet", "tempo-mainnet", "base-mainnet", "ethereum-mainnet", "robinhood", "tempo", "base", "ethereum". The -mainnet ones are the mainnets (beta…
- `payTo` (string): Payee receive tag (gloamr1.…). Omit to be paid to this server's own tag, which gloam_verify_payment can open.
- `realm` (string): MPP protection space for the challenge. Default: the resource URL's host.
- `resource` (string, required): What is being paid for: a URL or an MCP tool id.

### `gloam_pay_x402` (~175 tokens)

Plan a private payment for a 402 challenge

AGENT side. Given a Gloam 402 price (x402 requirements, or an MPP WWW-Authenticate: Payment challenge with method gloam), describe the private payment the agent would make: a self-custodial private send of the required amount to the payee, sealed to the payee's receive tag, broadcast by this server (no operator or facilitator holds its key). Plans only; to pay, call gloam_execute_private_pay, or gloam_fetch_paid to do the whole request.

Input parameters:

- `note` (string): Handle of the note to pay from (gloam_list_notes), if you want a specific one.
- `requirements` (string, required): Encoded requirements from gloam_payment_requirements (or the raw JSON), or an MPP challenge (the WWW-Authenticate value).

### `gloam_execute_private_pay` (~267 tokens)

Execute a private payment (x402 or MPP)

AGENT side, REAL execution. Settle a 402 price privately from a note this server holds: syncs the pool tree, builds the private send to the payee, seals the payment note to the payee's receive tag, generates the Groth16 transfer proof, and broadcasts transfer(). Self-custodial (this server's key signs; no operator holds funds). Returns the X-PAYMENT header for x402 requirements, or for an MPP challenge (method gloam) the Authorization: Payment credential, and the change as a note handle. A challenge is paid once, and a call whose answer never arrived is not paid twice: the retry reuses the first payment, or answers payment_in_progress while that one is running. payTo must be a receive tag. Requires GLOAM_AGENT_PRIVATE_KEY; without it, returns a plan.

Input parameters:

- `issuerTag` (string): Optional issuer tag to attach a compliance disclosure.
- `note` (string): Handle of the note to pay from (gloam_list_notes). Omit to use the smallest note that covers the amount.
- `requirements` (string, required): Encoded requirements from gloam_payment_requirements (or raw JSON), or an MPP challenge (the WWW-Authenticate: Payment value).

### `gloam_fetch_paid` (~468 tokens)

Fetch a paid resource (x402 or MPP, paid privately)

AGENT side, REAL execution. Request a URL; if it answers 402 with a Gloam private price, pay it privately from this server's notes (same limits as gloam_execute_private_pay), retry, and return the response. Understands both dialects: an MPP challenge (WWW-Authenticate: Payment with method gloam, answered with Authorization: Payment) is preferred when offered, else x402 (X-PAYMENT). Also pays x402 scheme gloam-cashout (a gateway on Robinhood Chain that pays out to a public address): a cash out of exactly the quoted USDG from this server's notes to that address, sent through the Gloam relay. The payee and the amount are public there; this server's wallet and balance are not. gloam-cashout needs maxAmount. With gloam-private and gloam-cashout both offered, gloam-private is paid unless prefer says gloam-cashout. The agent never handles a note secret or the payment header unless a retry is needed. A call whose answer never arrived is not paid twice: the same call again gets that answer, presents the first payment, or answers payment_in_progress while it is running. Requires GLOAM_AGENT_PRIVATE_KEY to pay.

Input parameters:

- `body` (string): Request body for POST.
- `contentType` (string): Content-Type for the body (default application/json).
- `maxAmount` (number): Refuse if the 402 asks for more than this, in the asset's units. Needs the asset's decimals from Gloam's list or the limits file; for any other asset the fetch is refused.
- `method` (string)
- `note` (string): Handle of the note to pay from; omit to use the smallest that covers the price.
- `paymentHeader` (string): Present a payment already made (paymentHeader from an earlier result: an X-PAYMENT value or an MPP Payment credential) instead of paying again.
- `prefer` (string): Which x402 scheme to pay when the resource offers both gloam-private and gloam-cashout. Default gloam-private, which keeps the payee private too.
- `url` (string, required): http(s) URL of the resource.

### `gloam_verify_payment` (~297 tokens)

Verify and settle a private payment (x402 or MPP)

SERVER side. Check a presented payment and make it final: an x402 X-PAYMENT value against its requirements, or an MPP credential (the Authorization: Payment value, method gloam) against the challenge it echoes, which must be one this server issued for this price (pass the price as requirements in both cases). Opens the payment note with this server's receive key, checks it binds the required amount and asset in the right pool (and, for MPP, that it is the payment output of a Transferred event and bound to that challenge), then sweeps it into a fresh note only this server knows and waits for that to confirm. Grant access only when the result says grantAccess: true; for MPP, serve with its paymentReceipt as the Payment-Receipt header. A payer creates the payment note, so without the sweep it could spend the money back after being served. Needs GLOAM_AGENT_PRIVATE_KEY or the relay (GLOAM_USE_RELAY=1) to sweep.

Input parameters:

- `payment` (string, required): The X-PAYMENT header value (or raw JSON payload), or the MPP Authorization: Payment value presented by the payer.
- `requirements` (string): The price of the resource you are serving: x402 requirements (encoded or raw JSON), or the MPP challenge (WWW-Authenticate value). Required for both x402 and MPP: the payment must match this price.

### `gloam_get_limits` (~131 tokens)

Spending limits

This agent's spending limits as the owner set them: which money tools it may use, which assets, the cap per payment and per rolling 24 hours, allowed recipients, and when its permission expires. Check this before planning a payment. This MCP server enforces them before it signs (off-chain). When the agent's key is a Tempo access key, the result also has `onchain`: the owner's AccountKeychain authorization (expiry, the remaining periodic limit and call scopes), which the Tempo protocol enforces on every transaction whatever this server does. The vault contract itself does not know about limits.

### `gloam_get_spending_report` (~69 tokens)

Spending report

What this agent has spent in the last 24 hours and how much is left under its daily limit, per asset, plus its most recent payments and any refused attempts. Read from the local spending log this server keeps.

Input parameters:

- `recent` (integer): How many recent payments to list.

## Diagnostics

Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/cryptoduke01-gloam/gloamtrade-mcp#diagnostics

## Score history

- 2026-11-05: 49
- 2026-11-04: 69
- 2026-11-03: 68
- 2026-11-02: 53
- 2026-11-01: 70
- 2026-10-31: 70
- 2026-10-30: 69
- 2026-10-29: 69
- 2026-10-28: 68
- 2026-10-27: 68
- 2026-10-26: 67
- 2026-10-25: 67
- 2026-10-24: 66
- 2026-10-23: 68
- 2026-10-22: 68
- 2026-10-21: 52
- 2026-10-20: 64
- 2026-10-19: 64
- 2026-10-18: 64
- 2026-10-17: 64
- 2026-10-16: 64
- 2026-10-15: 64
- 2026-10-14: 64
- 2026-10-13: 36
- 2026-10-12: 36
- 2026-10-11: 36

## Common questions

### What is the Gloam MCP server?

Gloam is an MCP server listed in the public MCP registry as io.github.cryptoduke01/gloam. Private stablecoin payments for people and AI agents on mainnet, hosted or local with limits. This page covers its npm package (@gloamtrade/mcp).

### Is the Gloam MCP server safe to use?

Gloam scores 49 out of 100 on VerifyMCP. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Gloam MCP server expose?

Gloam exposes 17 tools: gloam_info, gloam_privacy_status, gloam_swap_quote, gloam_execute_private_swap, gloam_finish_swap, and 12 more. Their descriptions and schemas cost roughly 3,706 tokens of context every time the server is loaded.

### Is the Gloam MCP server still maintained?

Gloam is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Gloam MCP server under?

Gloam declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the Gloam MCP server?

VerifyMCP ran 13 checks on Gloam, covering Install scripts, Source repository, Provenance, License and 9 more. 3 items could not be completed, a gap on our side rather than a finding about Gloam: Malware scan, Known CVEs and Dependency health. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/@gloamtrade/mcp
- Socket report: https://socket.dev/npm/package/@gloamtrade/mcp
- Repository: https://github.com/cryptoduke01/gloam
- Website: https://gloam.trade/docs/agents
- Changelog RSS feed: https://verifymcp.io/servers/cryptoduke01-gloam/gloamtrade-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/cryptoduke01-gloam/gloamtrade-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/cryptoduke01-gloam/gloamtrade-mcp.json
- HTML version of this page: https://verifymcp.io/servers/cryptoduke01-gloam/gloamtrade-mcp