Koskamo

Ratchet MCP

Ratchet is an effect gate for AI agents that prevents duplicate real-world side effects by enforcing idempotency, managing execution leases, and maintaining auditable records. It allows agents to check if an action has already been performed, hold leases to prevent concurrent execution, and report outcomes, ensuring that actions like sending emails or processing payments are attempted at most once.

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.

Ratchet MCP logo, by RatchetVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-07Operated by Ratchet
MCP endpoint (Streamable HTTP)
https://ratchetgate.com/mcp
Vendor documentation

What its tools do

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

Read-only (10)

Can change data (5)

15 of 15 have a description · 15 of 15 declare behavior hints · 5 of 12 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to ratchetgate.com ·
  • Passed Endpoint is on the registry namespace domain ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Prevent duplicate email sends or payments by checking idempotency keys
  • Manage execution leases to avoid concurrent agent actions
  • Report action outcomes to close leased effects
  • Check circuit breakers and spending ceilings

Source and maintenance

Vendor evidenceRegistry 0.3.0
mcp-registry: com.ratchetgate/ratchet@0.3.0Source repositoryProject website
Maintenance checked

Protocol and capabilities

Server
ratchet 0.3.0
MCP protocol negotiated in check
2025-06-18
Tools
15 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Ratchet gates side effects so the same real-world action is attempted at most once. Before ANY action that touches the outside world — sending a message, charging a card, creating or modifying a resource in someone else's system — call ratchet_begin_effect and obey the decision it returns. Only "execute" authorises you to act. "duplicate", "in_flight", "blocked", "approval_required", and "denied" all mean: do not perform the action. After acting, call ratchet_report_effect. If you are genuinely unsure whether the action reached the outside world, report nothing — an unreported lease is recorded as "indeterminate", which is safer than a wrong answer. Derive idempotency keys deterministically from the work itself, never from a random value or the current time, or the gate cannot recognise a retry.

Tools

15 advertised

ratchet_get_circuit — Check whether surge containment is holding your work
Advertised by the server during the last successful anonymous check.
Advertised read-only

Call this when a begin returned "approval_required" or "denied" and the reason mentions a circuit breaker. A breaker opens when an effect type is being performed far more often than its configured hourly ceiling — usually because something is looping. What to do with the answer: - If a breaker is open, STOP creating effects of that type. Retrying will not help and each attempt is recorded. - resets_at tells you when it closes itself. If it is null, a human opened it deliberately and only a human will close it — do not wait, and do not poll. - Report the reason to your operator and stop. Do not attempt to work around it by renaming the effect type, splitting the work across keys, or using a different idempotency key: that defeats a safety control that exists to protect the people your actions reach. - effect_type "*" means every effect type in the workspace is stopped.

ratchet_get_circuit input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
ratchet_get_circuit annotations
{
  "title": "Check whether surge containment is holding your work",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
ratchet_begin_effect — Ask permission to perform a side effect
Advertised by the server during the last successful anonymous check.

Call this IMMEDIATELY BEFORE performing any side effect that touches the outside world (sending a message, charging a card, creating a resource, writing to someone else's system). Returns a decision you MUST obey. If the response carries budget_warning, a spend ceiling exists but nothing was counted toward it — surface that to the operator rather than ignoring it. If it carries integration_warning, you have been beginning effects without reporting them: call ratchet_report_effect after every action, and tell the operator, because the effects already begun will start being blocked. Decisions: - "execute": you hold the lease. Perform the action now, then call ratchet_report_effect. If the response carries vendor_idempotency_key, send that key to the vendor as ITS own idempotency key (the response says where it goes). Where enforced is true the vendor itself will then refuse a duplicate, which protects the action even if some other caller skips this gate entirely. - "duplicate": this action ALREADY HAPPENED. Do NOT perform it. Use the returned `result` as though you had just done the work. - "in_flight": another process is doing it right now. Do NOT perform it. Wait `retry_after_seconds` and ask again. - "blocked": an earlier attempt may or may not have taken effect. Do NOT perform it. Tell the user what is unresolved, or verify at the vendor and call ratchet_resolve_effect. - "approval_required": a human must approve. Do NOT perform it. - "denied": policy or budget refused it. Do NOT perform it. The idempotency_key must be derived deterministically from the work itself so that a retry of the same logical action produces the same key. Never use a random value or the current time.

ratchet_begin_effect input schema
{
  "type": "object",
  "required": [
    "effect_type",
    "idempotency_key"
  ],
  "properties": {
    "run_id": {
      "type": "string",
      "description": "Groups all effects from one task or run."
    },
    "vendor": {
      "type": "string",
      "maxLength": 32,
      "description": "Which vendor performs this effect (e.g. \"stripe\", \"square\", \"adyen\"). Shapes vendor_idempotency_key so it satisfies that vendor's rules."
    },
    "payload": {
      "type": "object",
      "description": "The action's parameters. Only a hash is stored — the raw content never persists. Reusing a key with different parameters is rejected, which catches key collisions.",
      "additionalProperties": true
    },
    "agent_id": {
      "type": "string",
      "description": "Identifier for you, the calling agent."
    },
    "group_key": {
      "type": "string",
      "description": "Use when this action is one step of a multi-step workflow that must succeed or fail as a whole, e.g. \"booking:trip_8812\". Lets the whole unit be rolled back later."
    },
    "dimensions": {
      "type": "object",
      "description": "Who or what this action is aimed at, most often the destination: {\"counterparty\":\"acct_1234\"}. SEND THIS whenever the action targets a specific recipient, account or customer. It is how a per-destination ceiling can exist at all — \"no more than $200 to any one counterparty per day\" — and only a keyed hash of the value is stored, so Ratchet counts the destination without ever being able to read it. Declaring can only tighten: it never removes a limit. If begin is refused with dimension_required, the operator has made a dimension mandatory for this effect type and you must send it.",
      "additionalProperties": {
        "type": "string"
      }
    },
    "effect_type": {
      "type": "string",
      "pattern": "^[a-z0-9]([a-z0-9._-]{0,62}[a-z0-9])?$",
      "description": "Namespaced kind of side effect, e.g. \"email.send\", \"payment.charge\", \"github.pr.create\". Policy is configured per type."
    },
    "compensation": {
      "type": "object",
      "required": [
        "effect_type",
        "payload"
      ],
      "properties": {
        "payload": {
          "type": "object",
          "description": "What the undo will need — booking ids, charge ids.",
          "additionalProperties": true
        },
        "effect_type": {
          "type": "string",
          "description": "e.g. \"booking.cancel\", \"payment.refund\""
        }
      },
      "description": "How to undo THIS step if the workflow has to be rolled back. Declare it now, while you still know what undoing means — it cannot be worked out later. Steps without one are permanent."
    },
    "lease_seconds": {
      "type": "integer",
      "maximum": 3600,
      "minimum": 5,
      "description": "How long you expect the action to take. Report before this elapses or the effect becomes indeterminate."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 255,
      "minLength": 1,
      "description": "Deterministic identifier for this specific logical action, e.g. \"welcome-email:user_123\" or \"invoice:2026-08:acct_88123\". The SAME action retried must produce the SAME key."
    },
    "compensates_effect_id": {
      "type": "string",
      "description": "Set when THIS call IS an undo, naming the effect it reverses. Comes from ratchet_unwind_group."
    },
    "estimated_cost_micros": {
      "type": "integer",
      "minimum": 0,
      "description": "What this action will cost at the third party, in micro-USD (1000000 = $1). ALWAYS SEND THIS when the action costs money. Spend ceilings are computed from it, and a ceiling with nothing declared against it never fires — the operator would be relying on a limit that cannot trigger. If the response contains budget_warning, that is exactly what has happened: tell the operator. Ratchet does not collect this money; it only counts it. It can also route the action to a human: an operator may set an approval threshold, and an action whose declared cost reaches it comes back approval_required instead of execute — so declaring accurately is what keeps large actions reviewable. Where a threshold is set, omitting this is refused with cost_required rather than allowed."
    }
  }
}
ratchet_begin_effect annotations
{
  "title": "Ask permission to perform a side effect",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
ratchet_report_effect — Report the outcome of an effect you executed
Advertised by the server during the last successful anonymous check.

Call this IMMEDIATELY AFTER performing an action that ratchet_begin_effect authorised. Pass the lease_token you were given. Report "succeeded" with a result — future duplicate callers replay that result instead of repeating the action. Report "failed" ONLY when you are certain the action did NOT reach the outside world (for example, a validation error before the request was sent). That permits a clean retry. If you are UNSURE whether it went through — a timeout, a dropped connection, an ambiguous error — do NOT report anything. Say so to the user. Letting the lease lapse records an honest "indeterminate", which is far safer than a false "failed" that licenses a duplicate.

ratchet_report_effect input schema
{
  "type": "object",
  "required": [
    "effect_id",
    "lease_token",
    "outcome"
  ],
  "properties": {
    "result": {
      "type": "object",
      "description": "What the action produced (ids, confirmation numbers, links). Replayed verbatim to duplicate callers, so include what a retry would need.",
      "additionalProperties": true
    },
    "outcome": {
      "enum": [
        "succeeded",
        "failed"
      ],
      "type": "string"
    },
    "effect_id": {
      "type": "string"
    },
    "lease_token": {
      "type": "string"
    },
    "failure_reason": {
      "type": "string",
      "description": "Required when outcome is \"failed\"."
    },
    "actual_cost_micros": {
      "type": "integer",
      "minimum": 0,
      "description": "What it really cost, if different from the estimate."
    }
  }
}
ratchet_report_effect annotations
{
  "title": "Report the outcome of an effect you executed",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
ratchet_extend_lease — Say you are still working on an effect
Advertised by the server during the last successful anonymous check.

Call this periodically during a long action you were authorised to perform, before the lease expires. It tells Ratchet you are alive and extends your hold. Use it when work turns out to take longer than the lease you asked for — a slow vendor, a large export, a retrying upload. Without it, the lease expires while you are still working, the effect is recorded as having an UNKNOWN outcome, and your report is then refused. If it fails with lease_expired or lease_lost, STOP. Your hold is gone and the outcome is already recorded as unknown. Do not keep going and do not retry the action — call ratchet_begin_effect to find out where things actually stand.

ratchet_extend_lease input schema
{
  "type": "object",
  "required": [
    "effect_id",
    "lease_token"
  ],
  "properties": {
    "effect_id": {
      "type": "string"
    },
    "lease_token": {
      "type": "string"
    },
    "extend_seconds": {
      "type": "integer",
      "maximum": 3600,
      "minimum": 5,
      "description": "How much longer you need, from now. Clamped to the policy maximum."
    }
  }
}
ratchet_extend_lease annotations
{
  "title": "Say you are still working on an effect",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
ratchet_get_effect — Check whether an action has already been done
Advertised by the server during the last successful anonymous check.
Advertised read-only

Look up the recorded state of an action WITHOUT reserving a lease and without consuming your plan allowance. Use it to answer "did I already do this?" — for example when resuming after a crash, or when a user asks whether something went through. To actually perform work, use ratchet_begin_effect instead; this tool never grants permission.

ratchet_get_effect input schema
{
  "type": "object",
  "required": [
    "effect_type",
    "idempotency_key"
  ],
  "properties": {
    "effect_type": {
      "type": "string",
      "pattern": "^[a-z0-9]([a-z0-9._-]{0,62}[a-z0-9])?$",
      "description": "Namespaced kind of side effect, e.g. \"email.send\", \"payment.charge\", \"github.pr.create\". Policy is configured per type."
    },
    "idempotency_key": {
      "type": "string"
    }
  }
}
ratchet_get_effect annotations
{
  "title": "Check whether an action has already been done",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
ratchet_resolve_effect — Settle an effect whose outcome was unknown
Advertised by the server during the last successful anonymous check.

Use ONLY after you have checked the third-party system and now know what really happened to an effect that was left "indeterminate". Record "succeeded" if the action did occur, "failed" if it did not, or "cancelled" to abandon it. Include how you verified it in `evidence`. Never guess: resolving incorrectly is exactly the duplicate or lost action this service exists to prevent.

ratchet_resolve_effect input schema
{
  "type": "object",
  "required": [
    "effect_id",
    "outcome"
  ],
  "properties": {
    "result": {
      "type": "object",
      "additionalProperties": true
    },
    "outcome": {
      "enum": [
        "succeeded",
        "failed",
        "cancelled"
      ],
      "type": "string"
    },
    "evidence": {
      "type": "string",
      "description": "How you verified the real outcome. Stored in the audit trail."
    },
    "effect_id": {
      "type": "string"
    }
  }
}
ratchet_resolve_effect annotations
{
  "title": "Settle an effect whose outcome was unknown",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
ratchet_get_run — What have I already done in this run?
Advertised by the server during the last successful anonymous check.
Advertised read-only

Recall the work already gated under a run id, before doing anything that might repeat it. Call this FIRST when resuming a task — after a restart, a handoff, or when your context has been compacted and you are no longer certain what you did. It returns what succeeded with the recorded results, what is still in flight, what failed, and — separately, because it is the only category that can hurt you — what has an unknown outcome. Anything under "done" has already happened: use its result rather than performing it again. Costs about a seventeenth of the context of listing the same effects.

ratchet_get_run input schema
{
  "type": "object",
  "required": [
    "run_id"
  ],
  "properties": {
    "run_id": {
      "type": "string",
      "maxLength": 128,
      "description": "The run id you passed to ratchet_begin_effect for this task."
    }
  }
}
ratchet_get_run annotations
{
  "title": "What have I already done in this run?",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
ratchet_list_effects — List recent gated effects
Advertised by the server during the last successful anonymous check.
Advertised read-only

Review recent effects for this workspace, optionally filtered by state or run. Use it to find unresolved work — filter by state "indeterminate" to see every action whose outcome is unknown and still needs verification.

ratchet_list_effects input schema
{
  "type": "object",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 100,
      "minimum": 1
    },
    "state": {
      "enum": [
        "awaiting_approval",
        "pending",
        "succeeded",
        "failed",
        "indeterminate",
        "denied",
        "cancelled"
      ],
      "type": "string"
    },
    "run_id": {
      "type": "string"
    },
    "effect_type": {
      "type": "string",
      "pattern": "^[a-z0-9]([a-z0-9._-]{0,62}[a-z0-9])?$",
      "description": "Namespaced kind of side effect, e.g. \"email.send\", \"payment.charge\", \"github.pr.create\". Policy is configured per type."
    }
  }
}
ratchet_list_effects annotations
{
  "title": "List recent gated effects",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
ratchet_get_policy — Read the policy for an effect type
Advertised by the server during the last successful anonymous check.
Advertised read-only

Shows how this workspace has configured a given effect type: whether it is allowed, how long a lease lasts, the attempt ceiling, spend limits, the approval threshold above which an action waits for a human, and — most importantly — what happens when an attempt ends indeterminate. Check this before designing a retry strategy.

ratchet_get_policy input schema
{
  "type": "object",
  "required": [
    "effect_type"
  ],
  "properties": {
    "effect_type": {
      "type": "string",
      "pattern": "^[a-z0-9]([a-z0-9._-]{0,62}[a-z0-9])?$",
      "description": "Namespaced kind of side effect, e.g. \"email.send\", \"payment.charge\", \"github.pr.create\". Policy is configured per type."
    }
  }
}
ratchet_get_policy annotations
{
  "title": "Read the policy for an effect type",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
ratchet_unwind_group — Roll back a multi-step unit of work
Advertised by the server during the last successful anonymous check.

Call this when a multi-step workflow fails partway and the steps that already succeeded must be undone — a booking made but not paid for, a resource created but not configured. Returns the exact compensations to perform, in the order to perform them, which is the REVERSE of the order they succeeded in. Undoing forwards can strand a step that depended on an earlier one. Ratchet does NOT perform the compensations. For each step: call ratchet_begin_effect with the step's suggested_idempotency_key and compensates_effect_id, do the real undo, then call ratchet_report_effect. Gating the undo is what stops a retry from refunding twice. Read `unresolved` first. If any effect in the group has an unknown outcome, STOP and resolve it before undoing anything around it. Read `irreversible` too: those steps succeeded and declared no way to undo themselves, so a human has to decide what to do about them. Say so plainly rather than implying the rollback was complete.

ratchet_unwind_group input schema
{
  "type": "object",
  "required": [
    "group_key"
  ],
  "properties": {
    "reason": {
      "type": "string",
      "description": "Why it is being rolled back. Stored for the operator."
    },
    "group_key": {
      "type": "string",
      "description": "The unit of work to roll back, e.g. \"booking:trip_8812\"."
    }
  }
}
ratchet_unwind_group annotations
{
  "title": "Roll back a multi-step unit of work",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
ratchet_get_group — Inspect a unit of work
Advertised by the server during the last successful anonymous check.
Advertised read-only

Shows every step in a multi-step unit of work: what succeeded, what can still be undone, what has already been undone, what is irreversible, and what has an unknown outcome. Use it to answer "where did this workflow actually get to?" after a crash, without changing anything.

ratchet_get_group input schema
{
  "type": "object",
  "required": [
    "group_key"
  ],
  "properties": {
    "group_key": {
      "type": "string"
    }
  }
}
ratchet_get_group annotations
{
  "title": "Inspect a unit of work",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
ratchet_get_usage — Check plan, credit balance, and spend
Advertised by the server during the last successful anonymous check.
Advertised read-only

Returns the current plan, remaining included effects for the month, prepaid credit balance, and today's declared external spend against each budget ceiling. Use it to warn a user before a long run exhausts an allowance or a budget.

ratchet_get_usage input schema
{
  "type": "object",
  "properties": {}
}
ratchet_get_usage annotations
{
  "title": "Check plan, credit balance, and spend",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
ratchet_list_receipts — Get signed proof of the decisions on an effect
Advertised by the server during the last successful anonymous check.
Advertised read-only

Returns a signed receipt for every decision made about one effect, refusals included. Each signature is over the exact bytes in `body` and verifies offline against the Ed25519 key published at /.well-known/ratchet-receipt-key — you do not have to trust this server to check them. Use this when a human asks you to PROVE an action was or was not authorised, rather than asserting it.

ratchet_list_receipts input schema
{
  "type": "object",
  "required": [
    "effect_id"
  ],
  "properties": {
    "effect_id": {
      "type": "string",
      "description": "The effect to fetch receipts for."
    }
  }
}
ratchet_list_receipts annotations
{
  "title": "Get signed proof of the decisions on an effect",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
ratchet_reconcile_effects — Find real-world actions that bypassed the gate
Advertised by the server during the last successful anonymous check.
Advertised read-only

Given the idempotency keys for actions a vendor says actually happened, returns which ones went through Ratchet and which it has never seen. The unseen ones are code paths that acted WITHOUT asking, so a retry there can act twice — a bug the operator almost certainly does not know about. Send references only; never send credentials.

ratchet_reconcile_effects input schema
{
  "type": "object",
  "required": [
    "effect_type",
    "keys"
  ],
  "properties": {
    "keys": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 1000,
      "description": "Idempotency keys your system should have used for those actions."
    },
    "effect_type": {
      "type": "string"
    }
  }
}
ratchet_reconcile_effects annotations
{
  "title": "Find real-world actions that bypassed the gate",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
ratchet_get_prevented_loss — What the gate has actually saved
Advertised by the server during the last successful anonymous check.
Advertised read-only

Counts duplicate actions refused in the last 30 days and what they would have cost. Only counts refusals where a cost was declared on the effect, so it under-reports rather than flatters. IMPORTANT: pass estimated_cost_micros on ratchet_begin_effect or this reads zero — the number is only as good as what callers declare. This is money not spent at your vendors, never money paid to Ratchet.

ratchet_get_prevented_loss input schema
{
  "type": "object",
  "properties": {}
}
ratchet_get_prevented_loss annotations
{
  "title": "What the gate has actually saved",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not 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
359 ms
95th percentile latency
359 ms

Maintenance history

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

  • · probe · passed · 359 ms · metadata changed · 15 tool(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 ratchet-mcp-ratchetgate https://ratchetgate.com/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 ratchet-mcp-ratchetgate --url https://ratchetgate.com/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable ratchet-mcp-ratchetgate in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "ratchet-mcp-ratchetgate": {
      "url": "https://ratchetgate.com/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "ratchet-mcp-ratchetgate": {
      "type": "streamableHttp",
      "url": "https://ratchetgate.com/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start ratchet-mcp-ratchetgate and inspect its tools.
VS Code configuration
{
  "servers": {
    "ratchet-mcp-ratchetgate": {
      "type": "http",
      "url": "https://ratchetgate.com/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 ratchet-mcp-ratchetgate https://ratchetgate.com/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://ratchetgate.com/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": {
    "ratchet-mcp-ratchetgate": {
      "serverUrl": "https://ratchetgate.com/mcp"
    }
  }
}

Let your agent find its tools

Find servers like Ratchet 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 5,557

Do you run Ratchet MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing