Koskamo

Ask a human expert MCP

An MCP server that allows AI agents to interact with a human expert for consultations on software, optimization, and AI. It enables agents to submit requests, pay via PayPal or crypto, and retrieve expert replies without email, supporting tools for terms, status, submission, and follow-ups.

Visit Cristian Desivo

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.

Ask a human expert MCP logo, by Cristian DesivoVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-01Operated by Cristian Desivo
MCP endpoint (Streamable HTTP)
https://cristiandesivo.com/mcp
Vendor documentation

What you can do with it

  • Submit a technical problem for expert consultation
  • Pay for a response using PayPal or crypto
  • Retrieve expert replies by request ID
  • Send follow-up messages in a thread

Source and maintenance

Vendor evidenceRegistry 1.0.1
mcp-registry: com.cristiandesivo/ask-a-human@1.0.1Project website

Protocol and capabilities

Server
ask-a-human 1.0.0
MCP protocol
2025-06-18
Tools
6 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {}
}

Server-provided instructions

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

Ask a human expert: Cristian Desivo (mathematics and computer science, 10 years of experience) reads the summary of a problem you or your user are stuck on and replies himself, by email, with his most creative solution idea. 20 USD per request, paid by PayPal before you submit (unless get_status shows free_trial): at the link in get_terms, or sent to cdesivo92@gmail.com, which an agent with PayPal API access (for example the Payouts API) can do on its own. Or pay 25 USDT on TRON (TRC-20) from a crypto wallet (the address is in get_terms) and pass crypto_tx and network instead of transaction_id: the transfer is checked on the chain right away. Steps: get_status, get_terms, then submit_request with the payment's transaction ID, a reply email and a summary of up to 300 words. submit_request returns a request_id: call get_reply with it to read my reply here once I've written it (it's also emailed to the reply email), and send_followup to continue in the same thread at no extra cost; if you lose the request_id, find_request gives it back from the payment's transaction ID and the reply email. Requests can't be cancelled once submitted; if I can't help with it, I'll say so in my reply. Reviews from past clients: https://www.freelancer.com/u/cdesivo92 (more in credentials, in get_terms). The offer as a page: https://cristiandesivo.com/ask/

Tools

6 advertised

get_terms — Offer terms
Advertised by the server during the last successful anonymous check.
Advertised read-only

The offer's full terms, in English: who answers, what you get, the price, hours, when first replies come, the PayPal pay_url, the crypto option (25 USD in stablecoins, with my wallet addresses), how to submit a request, and my track record (where to read reviews from past clients, and case studies with summaries), and an example request with the kind of reply you get. Use it once, before your first submit_request: to decide whether this fits your problem and to learn how to pay. The terms rarely change, so there's no need to call it again in the same session. Not for live availability: whether I'm online now, paused or offering a free trial comes from get_status. Not needed for follow-ups or replies (send_followup, get_reply).

get_terms input schema
{
  "type": "object",
  "additionalProperties": false
}
get_terms output schema
{
  "type": "object",
  "required": [
    "what_you_get",
    "summary_word_limit",
    "price",
    "hours",
    "pay_url",
    "request_steps"
  ],
  "properties": {
    "hours": {
      "type": "string"
    },
    "price": {
      "type": "object",
      "required": [
        "amount",
        "currency"
      ],
      "properties": {
        "amount": {
          "type": "number"
        },
        "currency": {
          "type": "string"
        }
      }
    },
    "reply": {
      "type": "object",
      "description": "Reading my reply over plain HTTP, by request_id"
    },
    "crypto": {
      "type": [
        "object",
        "null"
      ],
      "description": "Paying in crypto: price, networks and my addresses (null if not offered)"
    },
    "submit": {
      "type": "object",
      "description": "The same request as a plain HTTP form/JSON POST"
    },
    "example": {
      "type": "object",
      "description": "A made-up sample request and the kind of reply I write"
    },
    "pay_url": {
      "type": "string",
      "description": "Where a human pays before submit_request"
    },
    "privacy": {
      "type": "string",
      "description": "The privacy policy: what's collected, why, and how long"
    },
    "good_fit": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "hours_et": {
      "type": "object"
    },
    "hours_utc": {
      "type": "object"
    },
    "not_a_fit": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "background": {
      "type": "string"
    },
    "pay_by_api": {
      "type": "string"
    },
    "credentials": {
      "type": "object",
      "description": "Track record: where to read reviews from past clients, and past work with one-line summaries"
    },
    "larger_work": {
      "type": "string"
    },
    "open_to_any": {
      "type": "string"
    },
    "who_answers": {
      "type": "string"
    },
    "cancellation": {
      "type": "string"
    },
    "paypal_email": {
      "type": "string",
      "description": "The PayPal account to send the payment to, e.g. with the Payouts API"
    },
    "summary_rule": {
      "type": "string"
    },
    "what_you_get": {
      "type": "string"
    },
    "request_email": {
      "type": "string"
    },
    "request_steps": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "note_for_agents": {
      "type": "string"
    },
    "first_reply_online": {
      "type": "string"
    },
    "summary_word_limit": {
      "type": "integer"
    },
    "first_reply_offline": {
      "type": "string"
    }
  }
}
get_terms annotations
{
  "readOnlyHint": true,
  "openWorldHint": false
}
get_status — Online status
Advertised by the server during the last successful anonymous check.
Advertised read-only

Whether I'm online right now (first reply within 15 minutes) or when I'm back (next_online_utc), whether requests are paused, and whether you've been awarded a free trial right now (then no payment or transaction_id is needed). Changes over time: call it right before paying and submitting, so you don't pay while requests are paused, and to know when to expect the reply. For the price, how to pay and what you get, use get_terms; to check on a request already sent, use get_reply.

get_status input schema
{
  "type": "object",
  "additionalProperties": false
}
get_status output schema
{
  "type": "object",
  "required": [
    "online",
    "paused",
    "next_online_utc",
    "checked_at_utc",
    "free_trial",
    "first_reply",
    "note"
  ],
  "properties": {
    "note": {
      "type": "string"
    },
    "online": {
      "type": "boolean",
      "description": "Online now: first reply within 15 minutes"
    },
    "paused": {
      "type": "boolean",
      "description": "Not taking requests right now"
    },
    "free_trial": {
      "type": "boolean",
      "description": "You've been awarded a free trial: no payment, no transaction_id"
    },
    "first_reply": {
      "type": "string",
      "description": "When the first reply comes if you submit now"
    },
    "checked_at_utc": {
      "type": "string"
    },
    "next_online_utc": {
      "type": [
        "string",
        "null"
      ],
      "description": "When offline: when I'm back"
    }
  }
}
get_status annotations
{
  "readOnlyHint": true,
  "openWorldHint": false
}
submit_request — Ask a human expert
Advertised by the server during the last successful anonymous check.
Open-world

Send a problem to Cristian Desivo, a human expert, for his most creative solution idea. Payment first: unless get_status shows free_trial, pay 20 USD by PayPal, either at https://paypal.me/CristianDesivo/20USD or by sending it to cdesivo92@gmail.com (an agent with PayPal API access, for example the Payouts API, can do this on its own), then pass the PayPal transaction ID; this tool takes no payments. Or pay 25 USDT on TRON (TRC-20) from a crypto wallet (the address is in get_terms) and pass crypto_tx and network instead of transaction_id: the transfer is checked on the chain right away. The summary is all I read for the first reply (300 words at most). I write the reply myself: within 15 minutes while I'm online, otherwise by 09:30 UTC. It's emailed to reply_email, and you can read it here with get_reply and the request_id this tool returns. A confirmation email goes to reply_email right away. At most 5 requests per hour from one address. Requests can't be cancelled once submitted; if I can't help with it, I'll say so in my reply.

submit_request input schema
{
  "type": "object",
  "required": [
    "reply_email",
    "summary"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Optional: your or your user's name"
    },
    "network": {
      "enum": [
        "tron"
      ],
      "type": "string",
      "description": "With crypto_tx: the network the transfer was made on"
    },
    "summary": {
      "type": "string",
      "description": "The problem in 300 words or fewer: what it is, what has been tried, the key constraints, and the deadline"
    },
    "crypto_tx": {
      "type": "string",
      "description": "Paying in crypto: the transaction hash of the transfer to my address (see crypto in get_terms), instead of transaction_id"
    },
    "payer_email": {
      "type": "string",
      "description": "Optional: the email of the PayPal account that paid, in case PayPal shows different transaction IDs"
    },
    "paypal_name": {
      "type": "string",
      "description": "Optional: the name on the PayPal account that paid, for the same reason"
    },
    "reply_email": {
      "type": "string",
      "description": "Where the confirmation and my reply go"
    },
    "transaction_id": {
      "type": "string",
      "description": "The PayPal transaction ID (17 letters and digits) of the payment made at pay_url or sent by PayPal to paypal_email. Required unless get_status shows free_trial or you pay in crypto (crypto_tx)"
    }
  },
  "additionalProperties": false
}
submit_request output schema
{
  "type": "object",
  "required": [
    "received"
  ],
  "properties": {
    "errors": {
      "type": "object",
      "description": "When not sent: the problem with each field (or 'form')",
      "additionalProperties": {
        "type": "string"
      }
    },
    "received": {
      "type": "boolean",
      "description": "True if the request was sent"
    },
    "reply_to": {
      "type": "string"
    },
    "get_reply": {
      "type": "string",
      "description": "The same check over plain HTTP (GET)"
    },
    "request_id": {
      "type": "string",
      "description": "Pass it to get_reply to read my reply"
    },
    "first_reply": {
      "type": "string"
    },
    "confirmation": {
      "type": "string"
    },
    "transaction_id": {
      "type": "string"
    }
  }
}
submit_request annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
get_reply — Read my reply
Advertised by the server during the last successful anonymous check.
Advertised read-only

My reply to a request you submitted, by the request_id submit_request returned (ask- followed by 24 letters, digits, - or _). status is 'waiting' until I've replied, with a note saying when to expect it, then 'replied' with the text, oldest first; later replies in the same thread are included. Check every few minutes, not in a tight loop: at most 120 checks per hour from one address. A malformed request_id is an error; a well-formed one I haven't answered yet is just 'waiting'. If you lost the request_id, use find_request; to reply to my answer, use send_followup. The same reply is also emailed to reply_email.

get_reply input schema
{
  "type": "object",
  "required": [
    "request_id"
  ],
  "properties": {
    "request_id": {
      "type": "string",
      "pattern": "^ask-[A-Za-z0-9_-]{24}$",
      "description": "The request_id submit_request (or find_request) returned, like ask-alWy4XCpgAW3eZUgwnRTCmQ2"
    }
  },
  "additionalProperties": false
}
get_reply output schema
{
  "type": "object",
  "properties": {
    "note": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "status": {
      "enum": [
        "waiting",
        "replied"
      ],
      "type": "string"
    },
    "replies": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "text": {
            "type": "string"
          },
          "sent_at_utc": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "request_id": {
      "type": "string"
    }
  }
}
get_reply annotations
{
  "readOnlyHint": true,
  "openWorldHint": false
}
send_followup — Follow up on a request
Advertised by the server during the last successful anonymous check.
Open-world

Send a follow-up in the thread of a request you submitted: answer a question I asked, add a detail I need, or ask the next question about the same problem. No new payment. Write it to stand on its own (I read it next to the thread, not in your session): say what changed or what you tried since my reply. The request_id must be one submit_request returned; an unknown one is refused and nothing is sent. My answer comes the same way as the first (get_reply, and email to reply_email). 300 words at most; at most 10 follow-ups per hour from one address. A new problem is a new request (submit_request).

send_followup input schema
{
  "type": "object",
  "required": [
    "request_id",
    "message"
  ],
  "properties": {
    "message": {
      "type": "string",
      "minLength": 1,
      "description": "Your follow-up, as plain text: an answer to my question, a clarification or a next question, written to stand on its own, 300 words or fewer"
    },
    "request_id": {
      "type": "string",
      "pattern": "^ask-[A-Za-z0-9_-]{24}$",
      "description": "The request_id submit_request (or find_request) returned, like ask-alWy4XCpgAW3eZUgwnRTCmQ2"
    }
  },
  "additionalProperties": false
}
send_followup output schema
{
  "type": "object",
  "required": [
    "sent"
  ],
  "properties": {
    "note": {
      "type": "string"
    },
    "sent": {
      "type": "boolean"
    },
    "error": {
      "type": "string"
    },
    "request_id": {
      "type": "string"
    }
  }
}
send_followup annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
find_request — Recover a request_id
Advertised by the server during the last successful anonymous check.
Advertised read-only

Lost the request_id of a request you submitted? Give the payment's transaction ID (PayPal ID or crypto hash) and the reply_email you used, and get the request_id back for get_reply and send_followup. Both must match the same request: if either doesn't, the answer is found: false, without saying which one was wrong. Case and spacing in the transaction ID don't matter. It's also in the confirmation email. At most 20 lookups per hour from one address.

find_request input schema
{
  "type": "object",
  "required": [
    "transaction_id",
    "reply_email"
  ],
  "properties": {
    "reply_email": {
      "type": "string",
      "description": "The reply_email you submitted the request with"
    },
    "transaction_id": {
      "type": "string",
      "description": "The payment's transaction ID: the PayPal ID, or the crypto hash you passed as crypto_tx"
    }
  },
  "additionalProperties": false
}
find_request output schema
{
  "type": "object",
  "required": [
    "found"
  ],
  "properties": {
    "error": {
      "type": "string"
    },
    "found": {
      "type": "boolean"
    },
    "get_reply": {
      "type": "string"
    },
    "request_id": {
      "type": "string"
    }
  }
}
find_request annotations
{
  "readOnlyHint": true,
  "openWorldHint": 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
391 ms
95th percentile latency
391 ms

Maintenance history

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

  • · probe · passed · 391 ms · metadata changed · 6 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 ask-a-human-expert-mcp https://cristiandesivo.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 ask-a-human-expert-mcp --url https://cristiandesivo.com/mcp

Cursor

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

Cline

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

VS Code

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

Claude Desktop

Merge this into claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\), then restart Claude Desktop.
Claude Desktop configuration
{
  "mcpServers": {
    "ask-a-human-expert-mcp": {
      "url": "https://cristiandesivo.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": {
    "ask-a-human-expert-mcp": {
      "serverUrl": "https://cristiandesivo.com/mcp"
    }
  }
}

Let your agent find its tools

Find servers like Ask a human expert 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 3,946

Do you run Ask a human expert 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