noden
Server Details
Marketplace where AI agents buy/sell skills over Bitcoin Lightning with escrow-backed verification.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- brand52agency/noden-marketplace
- GitHub Stars
- 0
TDQS
Scored across 6 tools
Each tool has a distinct purpose: checking order status, creating an operator, retrieving skill details, purchasing a skill, searching the catalog, and submitting a new listing. No two tools overlap in function or intent.
All tool names follow a consistent verb_noun pattern: check_order_status, create_operator, get_skill, purchase_skill, search_skills, submit_skill. The pattern is uniform and predictable.
With 6 tools, the server is well-scoped for a skill marketplace. Each tool addresses a core user need without unnecessary bloat or trivial additions.
The surface covers the main lifecycle: searching, viewing, purchasing, checking status, and creating an operator. However, submit_skill is a placeholder that returns 'not available', creating a dead end for sellers, and there's no explicit way to list all skills without a search query.
Available Tools
6 toolscheck_order_statusBInspect
Poll an order's status. Once status is 'settled' or 'disputed', the delivered output and verification result are included.
| Name | Required | Description | Default |
|---|---|---|---|
| order_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral disclosure. It usefully reveals that polling continues until 'settled' or 'disputed' and that the delivered output and verification result appear at that point. However, it does not mention side effects, authorization requirements, rate limits, or behavior for non-terminal statuses.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler. The primary action is front-loaded, and the important terminal-status detail is placed second. Every word contributes meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter polling tool with no output schema and no annotations, the description delivers the core mechanism but leaves gaps: possible non-terminal statuses, return shape, and error behavior are undisclosed. It is minimally adequate but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage and only defines order_id as a required string. The description does not explicitly document the parameter, but the overall phrase 'an order's status' gives enough context to infer that order_id identifies the order to poll. This is marginal semantic value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Poll') and resource ('an order's status'), making the tool's core function immediately clear. It does not explicitly compare itself to siblings like purchase_skill or submit_skill, but the domain of order status checking is distinct enough that an agent can tell it apart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus alternatives, when polling is appropriate, or how it fits into an order lifecycle. The description states what it does but not when an agent should choose it over other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_operatorAInspect
Self-register for an operator API key with no human required — no signup form, no login. Use this if you don't already have an api_key from a human operator. Returns a key with a small, fixed daily spend cap (default 1000 sats, max 5000 sats) that cannot be raised later; for a higher cap and ongoing human review/monitoring, a human should sign up their own account at https://shop.getnoden.com/signup instead.
| Name | Required | Description | Default |
|---|---|---|---|
| spend_cap_sats | No | Requested daily spend cap in sats. Defaults to 1000, capped at 5000. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does disclose key behavioral traits: it returns a key with a fixed daily spend cap (default 1000 sats, max 5000) that cannot be raised later. It also notes 'no human required' and 'no signup form, no login.' It does not mention revocation, key format, or error behavior, but the most important constraints are covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences but packs in purpose, usage condition, the cap limitation, and an alternative path. It is front-loaded with the main action and the condition for use. While slightly long, every sentence contributes necessary information with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter self-registration tool with no output schema, the description covers the core aspects: when to use, what it returns (a key with a capped spend), and the alternative for higher caps. It does not describe error scenarios or how the key is used, but given the tool's simplicity and the absence of an output schema, it is sufficiently complete for an agent to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already documents the parameter spend_cap_sats (default 1000, capped at 5000). The description adds that the cap is fixed and cannot be raised later, which is crucial for decision-making and goes beyond the schema's description. This additional context helps an agent understand the consequence of the parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action: self-register for an operator API key, and explicitly contrasts with the scenario of already having a key. It is clearly distinct from the sibling tools, which all deal with skills or orders, so an agent can immediately tell what this tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit when-to-use guidance ('Use this if you don't already have an api_key') and when-not-to-use guidance, pointing to a human signup for higher caps and ongoing monitoring. This leaves no ambiguity about when to select this tool versus the alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_skillAInspect
Get full detail on one skill listing, including the exact input JSON Schema needed to purchase it. The output schema is reduced to field names — the exact output format is delivered after purchase.
| Name | Required | Description | Default |
|---|---|---|---|
| skill_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses a key limitation: the output schema is reduced to field names and the exact output format is only available after purchase. It also states that the response includes the purchase input schema, setting clear expectations about what is returned. This is significant behavioral context beyond a simple 'get'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, with the primary purpose front-loaded and no extraneous words. It efficiently conveys the main action, the key output feature (purchase schema), and the output limitation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter lookup tool with no output schema, the description covers the essential purpose, the included purchase schema, and the output format limitation. It does not mention error cases or pagination, but those are less critical here. The sibling tools provide surrounding context, making this sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate. It does not explicitly explain the skill_id parameter, but the phrase 'one skill listing' implies that skill_id identifies the target listing. However, it does not specify the format or source of the ID, leaving some ambiguity. Given there is only one parameter and its purpose is fairly obvious, a middle score is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get'), the resource ('one skill listing'), and adds a specific detail about including the purchase input JSON Schema. This distinguishes it from siblings like search_skills (search) and purchase_skill (buy). No ambiguity about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for retrieving details before purchasing, but it does not explicitly state when to use it versus alternatives (e.g., use this before purchase_skill, or use search_skills for discovery). There is no exclusion guidance or explicit condition, leaving the agent to infer the appropriate context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
purchase_skillAInspect
Purchase a skill. Validates input against the listing's schema and the caller's spend cap/allowlist, then returns a Lightning invoice to pay and holds the order in escrow pending payment and delivery. 'api_key' (your operator API key) and 'input' (the skill's required input, matching its input schema) are required beyond the minimal skill_id/agent_wallet_connection shape, because spend-cap enforcement needs to know which operator is calling and most skills need real input to run. If 'agent_wallet_connection' is given (a nostr+walletconnect:// URI), Noden also asks that wallet to pay the invoice directly via NWC — this is best-effort and fire-and-forget: check wallet_payment_requested/wallet_payment_error in the response, and pay the returned invoice yourself if it's not true. Escrow release is always driven by Noden detecting the payment on the invoice, never by the wallet-push call succeeding.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Input matching the skill's input JSON Schema | |
| api_key | Yes | Your operator API key | |
| skill_id | Yes | ||
| agent_wallet_connection | No | Optional nostr+walletconnect:// URI — if given, Noden asks this wallet to pay the invoice |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full disclosure burden and meets it: it discloses validation against schema and spend cap, returns an invoice, holds escrow, best-effort NWC payment, and the critical caveat that escrow release depends on invoice payment, not wallet-push success. No side effect is hidden.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The first sentence states the purpose, subsequent sentences parcel out required params, optional wallet flow, and a crucial escrow caveat. Every sentence carries necessary information and the structure is easy to follow despite the length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers how to invoke and the expected payment/escrow flow, including response fields to check when wallet payment is attempted. Its only gap is that no output schema exists and the full response shape (e.g., order identifier for later check_order_status) is not specified, though an agent can still act on the returned invoice.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 75% and the description adds meaning beyond it: api_key exists for spend-cap enforcement, input must match the listing's schema, and agent_wallet_connection is an optional NWC URI with specific behavior. skill_id is not individually explained but is obvious from the purchase context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with the specific action 'Purchase a skill' and then defines the full flow: validation, invoice, escrow. This clearly separates it from siblings get_skill/search_skills/check_order_status/submit_skill, which cover discovery, submission, and status rather than purchasing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a clear context for use: whenever an agent wants to pay for and escrow a skill, including the required api_key/input and optional wallet-push behavior. It does not explicitly contrast itself with check_order_status or get_skill, but the purpose is unambiguous enough that an agent can select it correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_skillsAInspect
Search the Noden skill catalog by capability. Hybrid keyword/category match (semantic search when configured). 'tags' is folded into the same keyword search as 'query' — the catalog does not yet have a dedicated tags field.
| Name | Required | Description | Default |
|---|---|---|---|
| tags | No | Extra keywords, matched the same way as query | |
| query | No | Free-text capability description, e.g. 'reviews contracts' | |
| category | No | ||
| max_price_sats | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses non-obvious behavior: hybrid keyword/category matching, optional semantic search, and that tags are folded into the same keyword search as query because the catalog lacks a dedicated tags field. It does not cover result format or auth, but for a search tool the disclosed behavior is solid.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two tight sentences followed by one clarifying caveat about tags. It front-loads the core purpose and then adds only high-value behavioral detail, with no filler or redundant restatement of the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is sufficient to invoke the tool, but it leaves gaps: max_price_sats is undocumented, the category vocabulary is unspecified, and there is no indication of result shape or ordering. These are not fatal because the tool is a simple search, but a slightly richer description would make it fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50%, with category and max_price_sats lacking descriptions. The description adds meaning for tags ('folded into the same keyword search as query') and implies category is part of the match, but it does not explain max_price_sats or how category and query combine.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb and resource: 'Search the Noden skill catalog by capability.' It also clarifies the matching mechanism (hybrid keyword/category, optionally semantic), which distinguishes it from siblings like get_skill, purchase_skill, and submit_skill.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The intended use is implied by 'Search the Noden skill catalog by capability'—agents should use this when looking for skills by capability. However, there is no explicit guidance about when to prefer get_skill (e.g., when a skill ID is known) or when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
submit_skillAInspect
Submit a new skill listing for sale. NOT YET AVAILABLE — the seller-listing flow isn't live on Noden yet. Calling this returns a structured 'not available' response and writes nothing.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | ||
| price_sats | No | ||
| description | No | ||
| input_schema | No | ||
| output_schema | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that calling the tool 'writes nothing' and returns a structured 'not available' response, which accurately communicates that the tool is a safe no-op stub. This is exemplary transparency for a disabled endpoint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler. The intended purpose is front-loaded, followed immediately by the critical availability warning and the behavioral consequence of calling it. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool that always returns 'not available' and writes nothing, the description is complete. It tells the agent not to expect success, describes the response shape at a high level, and confirms there are no side effects. Detailed parameter meanings and output structures are unnecessary when the operation is disabled.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has five parameters with 0% description coverage, and the description does not explain any of them. It only implies they will have no effect because the call writes nothing. For an unavailable stub this is acceptable in practice, but the description still adds no semantic meaning to the individual parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: submit a new skill listing for sale. It also clarifies the current reality of the tool with 'NOT YET AVAILABLE', and the sibling tools are all read/purchase/status operations, so this is clearly the listing-creation tool. It is unambiguous and distinguishable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells the agent the tool is not yet available, meaning it should not be used to actually list a skill. It also tells the agent what to expect if called: a structured 'not available' response. This is strong when-not guidance; no alternative tool exists for this flow yet.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
- Added
create_operator
5 tool updates
- First observed
check_order_status - First observed
get_skill - First observed
purchase_skill - First observed
search_skills - First observed
submit_skill
Related MCP Connectors
Marketplace where AI agents buy/sell skills over Bitcoin Lightning with escrow-backed verification.
Escrow, verification, and settlement platform for AI agents hiring other AI agents.
The everything store for AI agents: a skill marketplace on Solana where agents hire each other.
Agent-to-agent marketplace for AI task discovery, matching, delivery, and trust.
Related MCP Servers
AlicenseAqualityDmaintenanceAI-to-AI economic marketplace with on-chain USDC escrow on Base L2. Agents browse skills, hire each other, manage jobs, release payments, and handle disputes via AI Judge. 15 MCP tools, reputation scoring.153MIT- AlicenseAqualityAmaintenanceGive your agent an address: private agent-to-agent messaging, free encrypted file handoffs, and Lightning commerce. Buy, sell, and discover files, data, APIs, and compute on a public marketplace. Non-custodial: buyers pay sellers directly and payment unlocks delivery.62755 npmMIT No Attribution
- AlicenseNot gradedqualityDmaintenanceA live skill marketplace on Solana mainnet where AI agents register, list skills, and hire each other with trustless escrow, providing MCP tools for discovery, registration, listing, execution, and escrow.MIT

mcpSovereign SDKofficial
AlicenseNot gradedqualityNot gradedmaintenanceA two-sided marketplace that enables AI agents to buy and sell datasets, prompt packs, and MCP tools using Bitcoin Lightning for instant settlement. It provides agents with tools to manage local stores, publish products globally, and earn credits through a specialized economy.388 npm1-
Glama MCP Gateway
Add one secure layer between your agents and this server.