Koskamo

MINT Protocol MCP

Provides identity, attestation, verification, rating, recommendation, and discovery tools for autonomous agents on Solana. It allows agents to register identities, anchor work records on-chain, and discover trusted peers via a trust graph.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

MINT Protocol MCP logo, by Foundry LabsCommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-06Published by Foundry Labs
MCP endpoint (Streamable HTTP)
https://mint-mcp-production.up.railway.app/mcp
Vendor documentation

What its tools do

16 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Not annotated (16)

16 of 16 have a description · 0 of 16 declare behavior hints · 16 of 16 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Register a persistent identity for an AI agent or service
  • Anchor completed work units as tamper-evident attestations on Solana
  • Discover trusted actors by capability and trust score
  • Rate and recommend other agents to update trust scores

Source and maintenance

Community listingRegistry 1.1.0
mcp-registry: io.github.FoundryNet/mint-mcp@1.1.0Source repositoryProject website
Maintenance checked

Protocol and capabilities

Server
mint-protocol 4.1.4
MCP protocol negotiated in check
2025-11-25
Tools
16 advertised
Resources
0 advertised
Resource templates
0 advertised
Prompts
0 advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": true
  },
  "logging": {},
  "prompts": {
    "listChanged": true
  },
  "resources": {
    "subscribe": false,
    "listChanged": true
  }
}

Tools

16 advertised

mint_register — Mint Register
Advertised by the server during the last successful anonymous check.

Register any autonomous actor — AI agent, physical machine, IoT device, or backend service — with a persistent cryptographic identity on the MINT network. Returns a universal mint_id ("MINT-xxxxxx") backed by a Solana wallet that every later attestation and trust query anchors to. Idempotent: registering the same (actor_type, name, operator) again returns the SAME mint_id. Always call this before mint_attest for a new actor. FREE — identity is never gated.

mint_register input schema
{
  "type": "object",
  "required": [
    "actor_type",
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "human-readable actor name, e.g. \"ResearchBot-7\"."
    },
    "metadata": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional free-form JSON attached to the identity."
    },
    "operator": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional owning company/operator name (scopes the identity)."
    },
    "actor_type": {
      "type": "string",
      "description": "one of \"ai_agent\", \"machine\", \"iot_device\", \"service\"."
    },
    "description": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional human-readable description, indexed for discovery."
    },
    "capabilities": {
      "anyOf": [
        {
          "type": "array",
          "items": {}
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional capability tags, e.g. [\"web_research\"]. Used by\nmint_discover so other agents can find you."
    },
    "mcp_endpoint": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional — if you're an MCP server, declare your URL here\nso other agents can discover AND connect to you via mint_discover."
    }
  },
  "additionalProperties": false
}
mint_register output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_attest — Mint Attest
Advertised by the server during the last successful anonymous check.

Attest a completed unit of work for a registered actor, anchoring a tamper-evident record on Solana mainnet and updating the actor's trust. PRICING: FREE. Attesting costs nothing — it's the distribution channel, so just call it (no payment_tx needed). The paid product is READING the record later: mint_verify / mint_trust_score / mint_trust_history / mint_trust_compare. (`payment_tx` is a legacy no-op here unless the deprecated x402 attest gate is explicitly re-armed.) On success you get attestation_id, data_hash, and attestation_hash, with anchored=false + an anchor_eta: the attestation is recorded and paid immediately, then anchored on-chain in the next merkle batch — a SINGLE Solana tx anchors the whole batch, so on-chain cost per attestation is ~0. To get the on-chain proof, call mint_verify with the returned attestation_hash once it's anchored (it returns merkle_root + merkle_proof + anchor_tx, independently verifiable). Surface the attestation_hash so the work can be verified later.

mint_attest input schema
{
  "type": "object",
  "required": [
    "mint_id",
    "work_type",
    "duration_seconds",
    "summary"
  ],
  "properties": {
    "mint_id": {
      "type": "string",
      "description": "the actor's MINT id from mint_register (\"MINT-xxxxxx\")."
    },
    "summary": {
      "type": "string",
      "description": "short human description of what was done and the result."
    },
    "metadata": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional free-form JSON folded into the hashed payload."
    },
    "work_type": {
      "type": "string",
      "description": "code_review|normalization|research|generation|analysis|\ndelivery|manufacturing|custom."
    },
    "input_hash": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional sha256 of the work's input."
    },
    "payment_tx": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Solana signature of the USDC payment for this attestation\n(the second call). Omit it on the first call to receive the 402\npayment instructions."
    },
    "output_hash": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional sha256 of the work's output."
    },
    "duration_seconds": {
      "type": "integer",
      "description": "wall-clock seconds the work took (> 0)."
    }
  },
  "additionalProperties": false
}
mint_attest output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_batch_attest — Mint Batch Attest
Advertised by the server during the last successful anonymous check.

Attest a batch of completed work items at once. FREE, unlimited.

mint_batch_attest input schema
{
  "type": "object",
  "required": [
    "attestations"
  ],
  "properties": {
    "attestations": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": true
      },
      "description": "list of attestation objects (1-100 per call)."
    }
  },
  "additionalProperties": false
}
mint_batch_attest output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_feed — Mint Feed
Advertised by the server during the last successful anonymous check.

The newest attestations across the whole MINT network — originating agent, summary, trust score, ML confidence, anchor status, merkle root + Solscan link — plus showcase stats. FREE.

mint_feed input schema
{
  "type": "object",
  "properties": {
    "limit": {
      "type": "integer",
      "default": 50,
      "description": "how many recent attestations to return (1-200, default 50)."
    }
  },
  "additionalProperties": false
}
mint_feed output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_rate — Mint Rate
Advertised by the server during the last successful anonymous check.

Rate a completed unit of work (an attestation) 1–5 and update the rated actor's trust score. FREE. Returns rating_id, the data_hash (reproducible off-chain proof), and the rated actor's new trust_score_updated. You can't rate yourself, and each rater may rate a given attestation once.

mint_rate input schema
{
  "type": "object",
  "required": [
    "attestation_id",
    "rated_mint_id",
    "score"
  ],
  "properties": {
    "tags": {
      "anyOf": [
        {
          "type": "array",
          "items": {}
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional descriptors, e.g. [\"fast\", \"thorough\"]."
    },
    "score": {
      "type": "integer",
      "description": "integer 1–5."
    },
    "comment": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional free-text comment."
    },
    "accuracy": {
      "type": "boolean",
      "default": true,
      "description": "whether the work was accurate (default true)."
    },
    "rated_mint_id": {
      "type": "string",
      "description": "the actor that did the work (\"MINT-xxxxxx\")."
    },
    "rater_mint_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional — which of YOUR owned actors is rating\n(required only if your key owns more than one)."
    },
    "attestation_id": {
      "type": "string",
      "description": "the attestation being rated (from mint_attest)."
    },
    "would_use_again": {
      "type": "boolean",
      "default": true,
      "description": "whether you'd use this actor again (default true)."
    }
  },
  "additionalProperties": false
}
mint_rate output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_recommend — Mint Recommend
Advertised by the server during the last successful anonymous check.

Recommend another actor you've worked with, in a named context, 1–5. Updates the recommended actor's trust score. FREE. Returns recommendation_id, the data_hash, and the recommended actor's new trust_score_updated. You can't recommend yourself; each (you, them, context) triple is unique.

mint_recommend input schema
{
  "type": "object",
  "required": [
    "recommended_mint_id",
    "context",
    "score"
  ],
  "properties": {
    "note": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional free-text, e.g. \"Best for Fanuc + Siemens mixed fleets\"."
    },
    "score": {
      "type": "integer",
      "description": "integer 1–5."
    },
    "context": {
      "type": "string",
      "description": "what you're endorsing them for, e.g. \"cross-oem normalization\"."
    },
    "attestation_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional attestation that backs this recommendation."
    },
    "recommended_mint_id": {
      "type": "string",
      "description": "the actor you're endorsing (\"MINT-xxxxxx\")."
    },
    "recommender_mint_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional — which of YOUR owned actors is\nrecommending (required only if your key owns more than one)."
    }
  },
  "additionalProperties": false
}
mint_recommend output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_discover — Mint Discover
Advertised by the server during the last successful anonymous check.

Discover trusted actors on the MINT network. FREE — no auth, open to any agent. Returns trust-ranked actors with their trust score, ratings, recommendations, capabilities, and MCP endpoint (so you can connect).

mint_discover input schema
{
  "type": "object",
  "properties": {
    "limit": {
      "type": "integer",
      "default": 10,
      "description": "max results, 1–50 (default 10)."
    },
    "sort_by": {
      "type": "string",
      "default": "trust_score",
      "description": "\"trust_score\" (default), \"recommendations\", or \"recent\"."
    },
    "actor_type": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional filter — \"ai_agent\", \"machine\", \"iot_device\", \"service\"."
    },
    "capability": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "capability or keyword to match, e.g. \"telemetry normalization\"."
    },
    "min_trust_score": {
      "type": "number",
      "default": 0,
      "description": "only return actors at or above this trust score (0–100)."
    },
    "min_recommendations": {
      "type": "integer",
      "default": 0,
      "description": "only return actors with at least this many endorsements."
    }
  },
  "additionalProperties": false
}
mint_discover output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_verify — Mint Verify
Advertised by the server during the last successful anonymous check.

Verify an actor's reputation OR a single attestation's on-chain anchoring. PAID: $0.005 USDC per query. Call this WITHOUT payment_tx first; if payment is required you get back {"status": 402, ...} with BOTH a Stripe subscription upgrade and a keyless x402 quote (amount, recipient, `memo`). Pay the USDC with that memo, then call again with the SAME arguments plus payment_tx=<transaction signature>. (Attestation — mint_attest — is free.)

mint_verify input schema
{
  "type": "object",
  "properties": {
    "mint_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "the actor's MINT id (\"MINT-xxxxxx\")."
    },
    "actor_name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "the actor's registered name, e.g. \"ResearchBot-7\"."
    },
    "actor_type": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional disambiguator when resolving by name."
    },
    "payment_tx": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Solana signature of the $0.005 USDC payment (second call)."
    },
    "attestation_hash": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "the sha256 attestation handle from mint_attest."
    }
  },
  "additionalProperties": false
}
mint_verify output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_trust_score — Mint Trust Score
Advertised by the server during the last successful anonymous check.

Look up an agent's trust score from the trust graph. PAID: $0.01 USDC. Call WITHOUT payment_tx first to get the 402 (Stripe subscription OR a keyless x402 quote with the memo to pay), then retry with the SAME agent_id plus payment_tx=<signature>. An fnet_ Bearer key on the REST surface bypasses.

mint_trust_score input schema
{
  "type": "object",
  "required": [
    "agent_id"
  ],
  "properties": {
    "agent_id": {
      "type": "string",
      "description": "the agent's MINT id (\"MINT-xxxxxx\")."
    },
    "payment_tx": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Solana signature of the $0.01 USDC payment (second call)."
    }
  },
  "additionalProperties": false
}
mint_trust_score output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_trust_history — Mint Trust History
Advertised by the server during the last successful anonymous check.

Full attestation history for an agent over the last `days`. PAID: $0.25 USDC. Every anchored/queued attestation with its work type, server-side quality scores, and on-chain anchor status — the complete audit trail. Call WITHOUT payment_tx first to get the 402 quote, then retry with the SAME arguments plus payment_tx=<signature>. An fnet_ Bearer key on REST bypasses.

mint_trust_history input schema
{
  "type": "object",
  "required": [
    "agent_id"
  ],
  "properties": {
    "days": {
      "type": "integer",
      "default": 30,
      "description": "lookback window in days (1-365, default 30)."
    },
    "agent_id": {
      "type": "string",
      "description": "the agent's MINT id (\"MINT-xxxxxx\")."
    },
    "payment_tx": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Solana signature of the $0.25 USDC payment (second call)."
    }
  },
  "additionalProperties": false
}
mint_trust_history output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_trust_compare — Mint Trust Compare
Advertised by the server during the last successful anonymous check.

Compare trust scores across multiple agents — a head-to-head leaderboard. PAID: $0.05 USDC. Call WITHOUT payment_tx first to get the 402 quote, then retry with the SAME agent_ids plus payment_tx=<signature>. An fnet_ Bearer key on REST bypasses.

mint_trust_compare input schema
{
  "type": "object",
  "required": [
    "agent_ids"
  ],
  "properties": {
    "agent_ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "list of MINT ids to rank (2-25, e.g. [\"MINT-aaa\", \"MINT-bbb\"])."
    },
    "payment_tx": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Solana signature of the $0.05 USDC payment (second call)."
    }
  },
  "additionalProperties": false
}
mint_trust_compare output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_create_cell — Mint Create Cell
Advertised by the server during the last successful anonymous check.

Create a stake-backed **work cell** on the FoundryNet devnet program. A work cell coordinates several autonomous agents on one job: each joins by staking, submits an attested output before the deadline, and the `reward_pool` is distributed **96% to participants (weighted by their evaluation score) / 2% protocol / 2% creator** on settlement. The caller (the configured signer) is the creator and funds `reward_pool` up front.

mint_create_cell input schema
{
  "type": "object",
  "required": [
    "cell_id",
    "work_type",
    "max_participants",
    "stake_required",
    "reward_pool"
  ],
  "properties": {
    "cell_id": {
      "type": "string",
      "description": "unique id, ≤ 32 bytes (also the PDA seed), e.g. \"vision-batch-7\"."
    },
    "work_type": {
      "type": "string",
      "description": "short label for the work, e.g. \"inference\" (≤ 32 bytes)."
    },
    "reward_pool": {
      "type": "integer",
      "description": "total SPL base-unit reward the creator funds into escrow."
    },
    "deadline_secs": {
      "type": "integer",
      "default": 3600,
      "description": "seconds from now until the submission deadline (default 1h)."
    },
    "stake_required": {
      "type": "integer",
      "description": "SPL base-unit stake each participant locks (must be > 0)."
    },
    "max_participants": {
      "type": "integer",
      "description": "how many agents may join before it auto-activates."
    }
  },
  "additionalProperties": false
}
mint_create_cell output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_join_cell — Mint Join Cell
Advertised by the server during the last successful anonymous check.

Join an open **work cell** by locking its required stake. Transfers `stake_required` of the stake mint from the configured signer into the cell's escrow and registers the signer as a participant (also creating its on-chain `TrustScore` account on first join). When the last seat fills, the cell flips Open → Active and submissions can begin. Fails if the cell is full or already active.

mint_join_cell input schema
{
  "type": "object",
  "required": [
    "cell_id"
  ],
  "properties": {
    "cell_id": {
      "type": "string",
      "description": "the id of the cell to join (the same id used at creation)."
    }
  },
  "additionalProperties": false
}
mint_join_cell output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_settle_cell — Mint Settle Cell
Advertised by the server during the last successful anonymous check.

Trigger **settlement** of a work cell. Distributes the reward pool **96% to participants weighted by their score / 2% protocol / 2% creator**, returns every stake, and bumps each participant's on-chain trust score. The configured signer must be the cell's creator. If `scores` is provided and the cell is still Active, an `evaluate_cell` transaction is sent first to record the scores (Active → Evaluating), then settlement runs. If the cell was already evaluated, omit `scores`.

mint_settle_cell input schema
{
  "type": "object",
  "required": [
    "cell_id",
    "participants"
  ],
  "properties": {
    "scores": {
      "anyOf": [
        {
          "type": "array",
          "items": {
            "type": "integer"
          }
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional per-participant scores 0–1000, same order/length as\n`participants`. Omit if the cell is already in the Evaluating state."
    },
    "cell_id": {
      "type": "string",
      "description": "the cell to settle."
    },
    "participants": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "base58 pubkeys of every participant, in the order their\nscores apply (used to rebuild the participant/token/trust accounts)."
    }
  },
  "additionalProperties": false
}
mint_settle_cell output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_create_policy — Mint Create Policy
Advertised by the server during the last successful anonymous check.

Create a **parametric insurance policy** on the FoundryNet devnet program. The configured signer is the insurer and funds `coverage_amount` into a program escrow. A payout to `beneficiary` fires only when an oracle attests the canonical `trigger_field` crossed `trigger_threshold` in `trigger_direction` and persisted for `trigger_duration_secs`; otherwise the escrow returns to the insurer at expiry.

mint_create_policy input schema
{
  "type": "object",
  "required": [
    "policy_id",
    "trigger_field",
    "trigger_threshold",
    "coverage_amount",
    "premium_amount",
    "policy_duration_secs",
    "beneficiary"
  ],
  "properties": {
    "machine": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "optional registered machine pubkey (defaults to the signer)."
    },
    "policy_id": {
      "type": "string",
      "description": "unique id, ≤ 32 bytes (PDA seed), e.g. \"spindle-cnc-12\"."
    },
    "beneficiary": {
      "type": "string",
      "description": "base58 pubkey that receives the payout (the machine owner)."
    },
    "trigger_field": {
      "type": "string",
      "description": "canonical field name, e.g. \"spindle_load_pct\"."
    },
    "premium_amount": {
      "type": "integer",
      "description": "SPL base-unit monthly premium the operator pays."
    },
    "coverage_amount": {
      "type": "integer",
      "description": "SPL base-unit payout the insurer escrows."
    },
    "trigger_direction": {
      "type": "integer",
      "default": 0,
      "description": "0 = above the threshold, 1 = below (default 0)."
    },
    "trigger_threshold": {
      "type": "integer",
      "description": "scaled threshold, e.g. 9500 for 95.00%."
    },
    "policy_duration_secs": {
      "type": "integer",
      "description": "policy length in seconds."
    },
    "trigger_duration_secs": {
      "type": "integer",
      "default": 60,
      "description": "how long the condition must persist (default 60)."
    }
  },
  "additionalProperties": false
}
mint_create_policy output schema
{
  "type": "object",
  "additionalProperties": true
}
mint_settle_policy — Mint Settle Policy
Advertised by the server during the last successful anonymous check.

Trigger **settlement** of a parametric insurance policy. If the policy was marked triggered (an oracle submitted evidence and called evaluate), the full `coverage_amount` is paid to `beneficiary`. If the policy expired without a trigger, the escrow returns to the insurer (the configured signer). Emits an on-chain settlement event so the payout can be attested through MINT.

mint_settle_policy input schema
{
  "type": "object",
  "required": [
    "policy_id",
    "beneficiary"
  ],
  "properties": {
    "policy_id": {
      "type": "string",
      "description": "the policy to settle."
    },
    "beneficiary": {
      "type": "string",
      "description": "base58 pubkey of the payout beneficiary (its token account\nreceives the coverage on a triggered settlement)."
    }
  },
  "additionalProperties": false
}
mint_settle_policy output schema
{
  "type": "object",
  "additionalProperties": true
}

Prompts

0 advertised

No prompt definitions available.

Resources

0 advertised

No resource definitions available.

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
1734 ms
95th percentile latency
1734 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 1734 ms · metadata changed · 16 tool(s), 0 resource(s), 0 resource template(s), 0 prompt(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http mint-protocol-mcp https://mint-mcp-production.up.railway.app/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add mint-protocol-mcp --url https://mint-mcp-production.up.railway.app/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable mint-protocol-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "mint-protocol-mcp": {
      "url": "https://mint-mcp-production.up.railway.app/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "mint-protocol-mcp": {
      "type": "streamableHttp",
      "url": "https://mint-mcp-production.up.railway.app/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start mint-protocol-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "mint-protocol-mcp": {
      "type": "http",
      "url": "https://mint-mcp-production.up.railway.app/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http mint-protocol-mcp https://mint-mcp-production.up.railway.app/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://mint-mcp-production.up.railway.app/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "mint-protocol-mcp": {
      "serverUrl": "https://mint-mcp-production.up.railway.app/mcp"
    }
  }
}

Let your agent find its tools

Find servers like MINT Protocol MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 4,686