Qumge: Agent Capabilities & 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.

{
  "type": "object",
  "properties": {
    "qumge_key": {
      "type": "string",
      "description": "Optional: your Qumge API key, for clients that cannot set an Authorization header. Takes precedence over the header. Never echoed back."
    },
    "query": {
      "type": "string",
      "description": "What the user wants to do, in their own words. e.g. 'automate posting to social media', 'extract tables from PDFs'. Omit it to browse the top-ranked skills instead."
    },
    "category": {
      "type": "string",
      "description": "Optional. Narrow to one category. Call list_categories to see them.",
      "enum": [
        "automation-workflow",
        "api-integration",
        "ai-agent-dev",
        "design-frontend",
        "data-analytics",
        "code-review-debug",
        "content-writing",
        "code-write-refactor",
        "marketing-growth",
        "testing",
        "documentation",
        "devops-security",
        "database",
        "personal-productivity",
        "files-spreadsheets",
        "other"
      ]
    },
    "offset": {
      "type": "integer",
      "description": "Skip this many results — for paging through a long list.",
      "minimum": 0
    },
    "limit": {
      "type": "integer",
      "description": "How many to return. Default 5, max 10.",
      "minimum": 1,
      "maximum": 10
    }
  },
  "required": []
}

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). If the reply says the skill ships more files (REFERENCE.md, scripts/…), call again with include_files: true to get them and write each next to SKILL.md.

{
  "type": "object",
  "properties": {
    "qumge_key": {
      "type": "string",
      "description": "Optional: your Qumge API key, for clients that cannot set an Authorization header. Takes precedence over the header. Never echoed back."
    },
    "slug": {
      "type": "string",
      "description": "The skill's slug, e.g. 'AgriciDaniel/claude-seo/seo-google'. Comes from search_skills."
    },
    "include_files": {
      "type": "boolean",
      "description": "Also return the full text of the other files in the skill's folder. Off by default — they can be hundreds of KB. Use it when installing."
    }
  },
  "required": [
    "slug"
  ]
}

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

{
  "type": "object",
  "properties": {}
}

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.

{
  "type": "object",
  "properties": {
    "qumge_key": {
      "type": "string",
      "description": "Optional: your Qumge API key, for clients that cannot set an Authorization header. Takes precedence over the header. Never echoed back."
    },
    "query": {
      "type": "string",
      "description": "Optional. Filter by name or vendor, e.g. 'claude', 'gemini'."
    },
    "limit": {
      "type": "integer",
      "description": "How many to return. Default 20, max 60.",
      "minimum": 1,
      "maximum": 60
    }
  },
  "required": []
}

Search Qumge's paid apps — hosted services an agent can call, billed per call from the user's Qumge balance. 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_app.

{
  "type": "object",
  "properties": {
    "qumge_key": {
      "type": "string",
      "description": "Optional: your Qumge API key, for clients that cannot set an Authorization header. Takes precedence over the header. Never echoed back."
    },
    "query": {
      "type": "string",
      "description": "What the user wants done, in their own words. Omit to browse the most-used apps."
    },
    "limit": {
      "type": "integer",
      "description": "How many to return. Default 5, max 10.",
      "minimum": 1,
      "maximum": 10
    }
  },
  "required": []
}

Fetch one app's full price book and how to call it, by the slug returned from search_apps. Call this before using an app: it lists 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 cap for this app.

{
  "type": "object",
  "properties": {
    "qumge_key": {
      "type": "string",
      "description": "Optional: your Qumge API key, for clients that cannot set an Authorization header. Takes precedence over the header. Never echoed back."
    },
    "slug": {
      "type": "string",
      "description": "The app's slug, e.g. 'autowhisper'. Comes from search_apps."
    }
  },
  "required": [
    "slug"
  ]
}

Call an app 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 app directly. Routes and prices come from get_app. Needs the user's qumge key in the Authorization header. A 5xx from the app is free; a 402 means the user's balance or this app's monthly cap stopped it.

{
  "type": "object",
  "properties": {
    "qumge_key": {
      "type": "string",
      "description": "Optional: your Qumge API key, for clients that cannot set an Authorization header. Takes precedence over the header. Never echoed back."
    },
    "slug": {
      "type": "string",
      "description": "The app's slug, from search_apps."
    },
    "path": {
      "type": "string",
      "description": "The route path from get_app, e.g. '/api/videos'. A query string may be appended or passed separately in `query`."
    },
    "method": {
      "type": "string",
      "enum": [
        "GET",
        "POST",
        "PUT",
        "PATCH",
        "DELETE",
        "HEAD",
        "OPTIONS"
      ],
      "description": "HTTP method. Default GET — the routes and their methods are in get_app."
    },
    "query": {
      "type": "string",
      "description": "Query string without the leading '?'."
    },
    "body": {
      "type": [
        "object",
        "string"
      ],
      "description": "Request body. An object is sent as JSON; a string is sent as-is."
    },
    "content_type": {
      "type": "string",
      "description": "Only needed when `body` is a string and the app expects a specific type."
    },
    "accept": {
      "type": "string",
      "description": "Optional Accept header."
    }
  },
  "required": [
    "slug",
    "path"
  ]
}

The user's Qumge balance, plus what each app has spent this month against its monthly cap. 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 cap stopped the call — it returns the top-up link to hand to the user. Needs the user's qumge key.

{
  "type": "object",
  "properties": {
    "qumge_key": {
      "type": "string",
      "description": "Optional: your Qumge API key, for clients that cannot set an Authorization header. Takes precedence over the header. Never echoed back."
    }
  },
  "required": []
}

Open a developer account for the user (needs their qumge key). There is no review and no waiting: it takes effect immediately, and publish_app 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.

{
  "type": "object",
  "properties": {
    "qumge_key": {
      "type": "string",
      "description": "Optional: your Qumge API key, for clients that cannot set an Authorization header. Takes precedence over the header. Never echoed back."
    },
    "display_name": {
      "type": "string",
      "description": "The name shown on their app pages."
    },
    "country": {
      "type": "string",
      "description": "ISO code like \"US\" or \"CN\" (a full country name also works)."
    },
    "entity_type": {
      "type": "string",
      "enum": [
        "individual",
        "company"
      ],
      "description": "individual (default) or company."
    },
    "social_links": {
      "type": "array",
      "description": "Up to 6 public URLs (X, GitHub, LinkedIn, their website). The kind is guessed from the domain.",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "display_name",
    "country"
  ]
}

List the developer's own apps 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.

{
  "type": "object",
  "properties": {
    "qumge_key": {
      "type": "string",
      "description": "Optional: your Qumge API key, for clients that cannot set an Authorization header. Takes precedence over the header. Never echoed back."
    }
  },
  "required": []
}

Publish an app to Qumge on the developer's behalf (needs the developer's Qumge key in the Authorization header). Give it a name, the app's HTTPS base_url, and — if you can read them off the app — its price book (events with a unit price) and routes (with a per-call ceiling). It returns a DRAFT app plus the signing secret and usage key (shown once). Nothing is charged while it is a draft. There is no human review: after test_app passes, submit_app_review takes the app live immediately, and qumge spot-checks it afterwards (a spot check can suspend it).

{
  "type": "object",
  "properties": {
    "qumge_key": {
      "type": "string",
      "description": "Optional: your Qumge API key, for clients that cannot set an Authorization header. Takes precedence over the header. Never echoed back."
    },
    "name": {
      "type": "string",
      "description": "Human name shown in the store."
    },
    "slug": {
      "type": "string",
      "description": "Optional URL slug. Derived from the name when omitted."
    },
    "base_url": {
      "type": "string",
      "description": "Where the app lives. Must be https."
    },
    "summary": {
      "type": "string",
      "description": "One line describing what it does."
    },
    "keywords": {
      "type": "array",
      "description": "Other names for the same thing, any language, up to 20. Agents search with a request like \"scrape trending TikTok videos\" — the keywords are what makes that find this app.",
      "items": {
        "type": "string"
      }
    },
    "metering": {
      "type": "string",
      "enum": [
        "reported",
        "balance_delta"
      ],
      "description": "reported (the app tells us what to charge) or balance_delta (we read its balance)."
    },
    "support_url": {
      "type": "string",
      "description": "Where users ask for help. Shown on the app page."
    },
    "refund_policy_url": {
      "type": "string",
      "description": "Their refund policy, if they have one."
    },
    "skill_slug": {
      "type": "string",
      "description": "Optional. Attach an existing skill from the catalog to this app (its documentation then shows on the app page). Ignored if the slug is unknown."
    },
    "social_links": {
      "type": "array",
      "description": "Up to 6 public URLs for the developer (X, GitHub, LinkedIn, their website). Shown on every app page. The kind is guessed from the domain.",
      "items": {
        "type": "string"
      }
    },
    "balance_path": {
      "type": "string",
      "description": "Only for balance_delta: where we read the balance."
    },
    "balance_json_path": {
      "type": "string",
      "description": "Only for balance_delta: where in that response."
    },
    "unit_name": {
      "type": "string",
      "description": "What users buy, e.g. credit."
    },
    "events": {
      "type": "array",
      "description": "Price book events. unit_price_usd is in US dollars, e.g. 0.10.",
      "items": {
        "type": "object",
        "properties": {
          "key": {
            "type": "string"
          },
          "unit_price_usd": {
            "type": "number"
          },
          "label": {
            "type": "string"
          }
        },
        "required": [
          "key",
          "unit_price_usd"
        ]
      }
    },
    "routes": {
      "type": "array",
      "description": "HTTP routes. Billable routes need hold_usd (the most one call may cost).",
      "items": {
        "type": "object",
        "properties": {
          "method": {
            "type": "string"
          },
          "pattern": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "billable": {
            "type": "boolean"
          },
          "hold_usd": {
            "type": "number"
          },
          "settle": {
            "type": "string",
            "enum": [
              "on_response",
              "on_final"
            ]
          },
          "lane": {
            "type": "string",
            "enum": [
              "standard",
              "micro"
            ],
            "description": "standard (default: one ledger row per call) or micro — for routes priced below $0.001. A micro route must settle on_response, its per-call ceiling must be at most $0.01, and calls settle in per-minute buckets instead of one row each."
          },
          "rate_limit_per_min": {
            "type": "integer",
            "minimum": 60,
            "maximum": 3000,
            "description": "Micro lanes only: calls per minute per key (default 600)."
          }
        },
        "required": [
          "pattern"
        ]
      }
    }
  },
  "required": [
    "name",
    "base_url"
  ]
}

Check one of the developer's own apps: its status (draft / review / live / suspended) and how far the §9 review checklist has got. Needs the developer's Qumge key.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "description": "The app's slug."
    }
  },
  "required": [
    "slug"
  ]
}

Run an app's connection test and end-to-end self-test, and record both results on its review checklist. Do this after publish_app, before submit_app_review. The connection test pings base_url + /qumge/ping twice (a correctly signed request and a forged one); the end-to-end test calls the real routes in the app's price book once — a billable route is genuinely charged to the app's own account. Needs the developer's Qumge key.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "description": "The app's slug."
    }
  },
  "required": [
    "slug"
  ]
}

Take one of the developer's apps 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 app immediately and agents can call it — and be charged — from then on. Run test_app 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 app. Needs the developer's Qumge key.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "description": "The app's slug."
    }
  },
  "required": [
    "slug"
  ]
}