com.qumge/skills

Tools

• become_developer

  Open a developer account for the user (needs their qumge key). There is no review and no waiting: it takes effect immediately, and publish_cap works right after. Give a display name and an ISO country code; the country decides tax and payout rails later. Payout details and legal name are only needed when the user actually withdraws money.

  shallow
• call_cap

  Call a capability on the user's behalf and return its response. Use this when you cannot make the HTTP call yourself: qumge charges the user's qumge balance and forwards the call, so the price is identical to calling the cap directly. Operations and prices come from get_cap. Prefer `operation` + `input`: when the operation declares an input_schema, `input` is validated against it before anything is charged or forwarded. Needs the user's qumge key in the Authorization header. A 5xx from the cap is free; a 402 means the user's balance or this cap's monthly limit stopped it. (Older clients may still call this tool as call_app — it still works.)

  shallow
• cap_status

  Check one of the developer's own capabilities: its status (draft / review / live / suspended) and how far the publishing checklist has got. Needs the developer's Qumge key. (Older clients may still call this tool as app_status.)

  shallow
• get_balance

  The user's Qumge balance, plus what each capability has spent this month against its monthly limit. Call this before a paid call when the user asks whether they can afford it, and after a 402 that says the balance or a limit stopped the call — it returns the top-up link to hand to the user. Needs the user's qumge key.

  shallow
• get_bundle

  Fetch every SKILL.md in one bundle, in a single call. Write each returned skill to .claude/skills/<name>/SKILL.md (or the equivalent for the user's agent) and the whole set is installed — no other step is needed. Get the slug from list_bundles.

  shallow
• get_cap

  Fetch one capability's operations, prices and how to call it, by the slug returned from search_caps. Call this before using a cap: it lists each operation (by name), its input and output schema when the developer provided one, which routes are billable, the per-call maximum, when the call settles, and the error codes the caller may see. If the request carries the user's Qumge key, it also reports that user's monthly limit for this cap. (Older clients may still call this tool as get_app — it still works.)

  shallow
• get_earnings

  What a developer has earned and what is payable: the amount still inside the 30-day holdback, the amount sitting in their wallet (income from capabilities — the only part that can be withdrawn), and what has already been paid out, with the most recent entries. Matured purchase amounts move into the wallet automatically. Needs the developer's Qumge key.

  shallow
• get_skill

  Fetch the full SKILL.md content of one skill, by the slug returned from search_skills. Write the returned markdown to .claude/skills/<name>/SKILL.md (or the equivalent for the user's agent) and it is installed — no other step is needed.

  shallow
• list_bundles

  List Qumge's skill bundles. A bundle is a hand-picked set of skills that together get ONE job done — e.g. 'see what competitors are posting'. Use this when the user describes a goal rather than naming a tool, then call get_bundle to install the whole set in a single step.

  shallow
• list_caps

  List the developer's own capabilities with their status (draft / live / suspended) and slug. Use it before publishing to see what already exists, and after to check what went live. Needs the developer's qumge key. (Older clients may still call this tool as list_apps.)

  shallow
• list_categories

  List the skill categories and how many skills are in each. Useful when the user is browsing rather than looking for something specific.

  shallow
• list_models

  List the models this gateway can route to, best first. Every one is reachable with the same Qumge key — no per-vendor signup. Only tool-calling models are listed: an agent cannot use the others.

  shallow
• list_wanted

  What agents searched for on Qumge and found nothing: the demand side of the store, in the searchers' own words, with how often each was searched in the last 7 and 30 days. Useful before building or publishing a capability — it tells you what people already want. Only the search text is stored; no user and no IP.

  shallow
• publish_cap

  Every billed operation must deliver one complete result for one clear input (e.g. product URL in → finished video out); helper steps such as job status are free, and a result that needs several calls is wrapped into one endpoint — never sell partial steps. Publish a capability (cap) to Qumge on the developer's behalf (needs the developer's Qumge key in the Authorization header). Give it a name and either the API's HTTPS base_url or, for an existing remote MCP server, its mcp_url; and — if you can read them off the project — its price book (events with a unit price) and operations (routes with a per-call ceiling, and a `doc` describing input/output so agents know what to send). It returns a DRAFT cap plus the signing secret and usage key (shown once). Nothing is charged while it is a draft. There is no human review: after test_cap passes, submit_cap takes the cap live immediately, and qumge spot-checks it afterwards (a spot check can suspend it). (Older clients may still call this tool as publish_app.)

  shallow
• request_payout

  Ask for a payout of the developer's payable balance (capability income only — topped-up money cannot be withdrawn). Call it once without `confirmed` to get the estimate (amount, channel fee, withholding tax, what actually lands), show that to the user, and only then call again with confirmed: true. Needs the developer's Qumge key.

  shallow
• search_caps

  Search Qumge's capabilities — paid services an agent can call, billed per call from the user's Qumge balance. A capability (cap) is somebody's API or MCP server with a price list; to you it is a set of operations. Use this when the user wants something done rather than a skill to install: 'make a promo video', 'transcribe this call'. Returns the best few with pricing, measured success rate and latency, and the slug to pass to get_cap. (Older clients may still call this tool as search_apps — it still works.)

  shallow
• search_skills

  Search Qumge's curated catalog of agent skills (SKILL.md files) by what the user wants to accomplish. Use this whenever the user asks for a skill, tool, or capability — e.g. 'find me a skill for social media automation', 'is there a skill for SEO audits'. Returns the best few, ranked by how useful they actually are (an LLM read each one), with a one-line summary and the exact slug to pass to get_skill.

  shallow
• submit_cap

  Take one of the developer's capabilities live. Nothing is reviewed before launch and nobody approves it: when the three code-checked items pass (signature, end-to-end, price book), this publishes the cap immediately and agents can call it — and be charged — from then on. Run test_cap first (it records signature + end-to-end; the price book is recorded when it saves). Qumge spot-checks docs and support afterwards and can suspend the cap. Needs the developer's Qumge key. (Older clients may still call this tool as submit_app_review.)

  shallow
• test_cap

  Run a cap's connection test and end-to-end self-test, and record both results on its publishing checklist. Do this after publish_cap, before submit_cap. The connection test sends three requests to base_url + /qumge/ping (correctly signed, wrong secret, and a 10-minute-old timestamp — only the first may succeed); the end-to-end test calls one free and one billable operation directly on the cap (nothing is charged) and, for a route the cap reports itself, waits 2 seconds for its usage report. An MCP cap has each listed tool called once instead. It warns (without blocking) about billed operations that have no `doc`. Needs the developer's Qumge key. (Older clients may still call this tool as test_app.)

  shallow
• verify_domain

  Prove the developer owns the domain of their MCP server or API. Going live does not need it: an unverified cap is live and charges callers, but the developer's earnings from it stay frozen until this passes — verifying releases them. Call with the service's https url: if the domain (or a parent domain) is already verified it says so; otherwise it returns a one-line file to serve at /.well-known/qumge-verify.txt on that host (or a DNS TXT record with the same line). Put the file into the project so it ships with the next deploy, then call again with check: true. Needs the developer's Qumge key.

  shallow

Embed this server’s score

Tool count and median score across every tool in this server’s corpus — honest in a way a single cherry-picked tool’s badge wouldn’t be.

[![Vouch score](https://vouch.tools/api/servers/45d17c9a-4b25-4bfc-945b-feb91a9116cb/badge.svg)](https://vouch.tools/servers/45d17c9a-4b25-4bfc-945b-feb91a9116cb)