Server definition
- Hash
- sha256:16758e29d88585c079ef348f090adaf1039e59272a861dea20bebaf74a7283a3
- What it is
- What a remote MCP server returned when asked what it offers: 11 tools
The blob, as servednamed by its sha256
{
"instructions": "Agentic Keychain (Agent Skill ROI Registry & Benchmarking) is a registry that measures reusable agent skills and sells some of them, including its own, through Polar as merchant of record. If you are deciding whether a skill could make a task cheaper, resolve_task gives one compact answer for a task in plain words, and evaluate_capability returns the same deterministic recommend / not recommended / insufficient evidence answer with the arithmetic; not recommended is a normal answer. Ranking never depends on payment, and publisher claims never decide. These tools never charge; any purchase needs your operator to complete a hosted checkout.",
"tools": [
{
"description": "Assess two to five named capabilities side by side for the same inputs, with the same method and ak.offer.v1 offer shape as evaluate_capability. Use when: you already hold a shortlist of capability ids and want each one's decision, reasons and offer in one answer. Not for: finding candidates (search_capabilities) or a single capability (evaluate_capability). Input: the capability ids, plus the optional task, model, expected_runs, baseline_cost_estimate_usd, context and constraints that evaluate_capability reads. Output: ak.comparison.v1 with the results ranked by decision, lower-bound net saving, relevance and capability id, each with its reasons and an ak.offer.v1 offer.",
"inputSchema": {
"properties": {
"baseline_cost_estimate_usd": {
"description": "What one run of this task costs you today without the capability, in USD.",
"exclusiveMinimum": 0,
"type": "number"
},
"capabilities": {
"description": "Two to five capabilities to compare, each as an id, ak:// URI or slug.",
"items": {
"description": "Capability id (ak:publisher:name or ak:publisher:name:x.y.z), ak:// URI or slug.",
"type": "string"
},
"maxItems": 5,
"minItems": 2,
"type": "array"
},
"constraints": {
"description": "Limits you set for the answer; a capability outside them is reported as blocked, with the reason code.",
"properties": {
"max_cost_usd": {
"description": "The highest price in USD you accept; a capability priced above it is blocked (over_max_cost).",
"minimum": 0,
"type": "number"
},
"minimum_confidence": {
"description": "The lowest confidence in the measured saving you accept, from 0.5 to 0.999 (default 0.9); below it the answer is blocked (below_minimum_confidence).",
"maximum": 0.999,
"minimum": 0.5,
"type": "number"
}
},
"type": "object"
},
"context": {
"additionalProperties": {
"type": [
"string",
"number",
"integer",
"boolean"
]
},
"description": "Facts about your situation, keyed by the capability's parameter names (e.g. log_lines).",
"type": "object"
},
"expected_runs": {
"description": "How many times you expect to perform this kind of task.",
"minimum": 1,
"type": "integer"
},
"model": {
"description": "The model you run on, e.g. claude-sonnet-5. Savings are reported only for measured models.",
"type": "string"
},
"task": {
"description": "Plain description of the task you are about to do (at most 4000 characters).",
"type": "string"
}
},
"required": [
"capabilities"
],
"type": "object"
},
"name": "compare_capabilities",
"outputSchema": null
},
{
"description": "Per measured model: expected saving per run, break-even runs and net saving over expected_runs, with intervals, for one capability and no task. Use when: you know the capability and want its economics on each model the registry measured. Not for: a use-or-not answer for a task (evaluate_capability) or several candidates (compare_capabilities). Input: a capability id; add model to keep one model, and expected_runs with baseline_cost_estimate_usd for an estimate at your scale. Output: ak.roi.v1 with one economics entry per measured model; break-even runs is null when the interval does not show a saving, and your estimate is left out where success is not accepted or your baseline lies outside the measured range.",
"inputSchema": {
"properties": {
"baseline_cost_estimate_usd": {
"description": "What one run of this task costs you today without the capability, in USD.",
"exclusiveMinimum": 0,
"type": "number"
},
"capability": {
"description": "Capability id (ak:publisher:name or ak:publisher:name:x.y.z), ak:// URI or slug.",
"type": "string"
},
"expected_runs": {
"description": "How many times you expect to perform this kind of task.",
"minimum": 1,
"type": "integer"
},
"model": {
"description": "The model you run on, e.g. claude-sonnet-5. Savings are reported only for measured models.",
"type": "string"
}
},
"required": [
"capability"
],
"type": "object"
},
"name": "estimate_roi",
"outputSchema": null
},
{
"description": "Decide whether a registry capability is worth using or buying for your task, from registry-run benchmarks only. Use when: you have a task and want a recommend, do_not_recommend or undetermined answer with the arithmetic; name a capability to weigh only that one, or leave it out and the registry weighs its closest matches. Not for: one short answer without the arithmetic (resolve_task), a plain list of matches (search_capabilities), two to five named candidates side by side (compare_capabilities), or the break-even figures of one capability without a task (estimate_roi). Input: a plain task description; give model, expected_runs and baseline_cost_estimate_usd for a money estimate, and context for the conditions the capability declares. Output: ak.evaluation.v1 with decision, reasons, expected effect, price, confidence, operator_message, evaluation_id, next steps and an ak.offer.v1 offer (status, next_action, economics, the four evidence kinds listed apart). do_not_recommend is a normal answer.",
"inputSchema": {
"properties": {
"baseline_cost_estimate_usd": {
"description": "What one run of this task costs you today without the capability, in USD.",
"exclusiveMinimum": 0,
"type": "number"
},
"budget_policy": {
"description": "Your operator's spending policy; the answer says whether a purchase fits it. Every purchase still needs human approval.",
"properties": {
"absolute_purchase_limit_usd": {
"description": "The highest price in USD for one purchase; a price above it is outside the policy.",
"type": "number"
},
"auto_purchase": {
"description": "When your operator allows a purchase without asking first: enabled (true or false), max_price_usd, and minimum_expected_roi (expected net saving divided by the price). The answer says whether the policy would allow it; these tools never charge.",
"type": "object"
},
"human_approval_required": {
"description": "above_usd: a price above this amount in USD needs your operator's approval even where auto_purchase is enabled.",
"type": "object"
},
"monthly_budget_usd": {
"description": "Your operator's budget for this month in USD.",
"type": "number"
},
"spent_this_month_usd": {
"description": "What is already spent of that budget this month in USD (0 when left out).",
"type": "number"
}
},
"type": "object"
},
"capability": {
"description": "Capability id (ak:publisher:name or ak:publisher:name:x.y.z), ak:// URI or slug.",
"type": "string"
},
"constraints": {
"description": "Limits you set for the answer; a capability outside them is reported as blocked, with the reason code.",
"properties": {
"max_cost_usd": {
"description": "The highest price in USD you accept; a capability priced above it is blocked (over_max_cost).",
"minimum": 0,
"type": "number"
},
"minimum_confidence": {
"description": "The lowest confidence in the measured saving you accept, from 0.5 to 0.999 (default 0.9); below it the answer is blocked (below_minimum_confidence).",
"maximum": 0.999,
"minimum": 0.5,
"type": "number"
}
},
"type": "object"
},
"context": {
"additionalProperties": {
"type": [
"string",
"number",
"integer",
"boolean"
]
},
"description": "Facts about your situation, keyed by the capability's parameter names (e.g. log_lines).",
"type": "object"
},
"expected_runs": {
"description": "How many times you expect to perform this kind of task.",
"minimum": 1,
"type": "integer"
},
"model": {
"description": "The model you run on, e.g. claude-sonnet-5. Savings are reported only for measured models.",
"type": "string"
},
"task": {
"description": "Plain description of the task you are about to do (at most 4000 characters).",
"type": "string"
}
},
"required": [
"task"
],
"type": "object"
},
"name": "evaluate_capability",
"outputSchema": null
},
{
"description": "Registry-run benchmark summaries (labelled), publisher claims (labelled PUBLISHER CLAIMED) and the signed attestations of one capability. Use when: you want the measurements behind an answer (paired runs, model, fixtures, method) or want to check them yourself. Not for: an answer for your task (evaluate_capability) or artifact hashes and the log proof (get_provenance). Input: a capability id, ak:// URI or slug. Output: ak.benchmark.v1 with the evidence, the publisher claims, the attestations, the method and the limitations; publisher claims never decide anything.",
"inputSchema": {
"properties": {
"capability": {
"description": "Capability id (ak:publisher:name or ak:publisher:name:x.y.z), ak:// URI or slug.",
"type": "string"
}
},
"required": [
"capability"
],
"type": "object"
},
"name": "get_benchmark",
"outputSchema": null
},
{
"description": "The capability's card: purpose, use-when and do-not-use-when conditions, permissions, price, evidence summary, trust checks, links and a task-independent ak.offer.v1 offer. Use when: you can name a capability and want its facts, or want to check the conditions an evaluation asked about. Not for: an answer for your task (evaluate_capability) or the full benchmark records (get_benchmark). Input: a capability id, ak:// URI or slug, from a search, an evaluation or a page. Output: ak.capability.v1 with the card fields, parameters, versions, terms, evidence, trust and links.",
"inputSchema": {
"properties": {
"capability": {
"description": "Capability id (ak:publisher:name or ak:publisher:name:x.y.z), ak:// URI or slug.",
"type": "string"
}
},
"required": [
"capability"
],
"type": "object"
},
"name": "get_capability",
"outputSchema": null
},
{
"description": "Artifact hash, manifest hash, signed publisher and registry attestations and a transparency-log inclusion proof for one capability. Use when: you want to check that a package is the one the registry published and signed. Not for: benchmark results (get_benchmark) or the card (get_capability). Input: a capability id, ak:// URI or slug. Output: ak.provenance.v1 with the hashes, the attestations, an RFC 9162 inclusion proof against the signed tree head, the trust checks and the keys URL.",
"inputSchema": {
"properties": {
"capability": {
"description": "Capability id (ak:publisher:name or ak:publisher:name:x.y.z), ak:// URI or slug.",
"type": "string"
}
},
"required": [
"capability"
],
"type": "object"
},
"name": "get_provenance",
"outputSchema": null
},
{
"description": "A signed 15-minute price quote with the hosted checkout link. It charges nothing; a purchase requires operator approval in the hosted checkout. Use when: your operator wants the price and the checkout link of a capability that is for sale, for example after an evaluation answered recommend. Not for: deciding whether a capability is worth it (evaluate_capability); a free capability needs no quote. Input: the capability id and, if you evaluated first, the evaluation_id, which links the quote to that evaluation. Output: a quote_id and signed claims bound to the capability version, price, currency, terms and expiry, the checkout link and the unlock request; the price comes from the registry record only.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"capability": {
"description": "Capability id (ak:publisher:name or ak:publisher:name:x.y.z), ak:// URI or slug.",
"type": "string"
},
"evaluation_id": {
"description": "The evaluation_id from evaluate_capability, if you evaluated first.",
"pattern": "^ev_[a-z2-7]{26}$",
"type": "string"
}
},
"required": [
"capability"
],
"type": "object"
},
"name": "get_quote",
"outputSchema": null
},
{
"description": "Report how a capability worked for you. Stored as AGENT REPORTED; it never changes evidence labels, trust or ranking. Only the listed fields are accepted; no task text is kept. Use when: you ran a capability, or decided not to, and can say whether the task succeeded. Not for: questions about a capability (get_capability, get_benchmark). Input: the capability id and success; add evaluation_id or purchase_ref to link the report, the optional token, tool-call, latency and cost counts, and failure_reason only with success false. Output: whether the report was stored, its label and, for a failed paid capability, the remedy policy.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"baseline_cost_estimate_usd": {
"description": "What one run of this task costs you without the capability, in USD.",
"minimum": 0,
"type": "number"
},
"capability": {
"description": "Capability id (ak:publisher:name or ak:publisher:name:x.y.z), ak:// URI or slug.",
"type": "string"
},
"cost_usd": {
"description": "What the run cost you in USD.",
"minimum": 0,
"type": "number"
},
"evaluation_id": {
"description": "The evaluation_id from evaluate_capability, if you evaluated first.",
"pattern": "^ev_[a-z2-7]{26}$",
"type": "string"
},
"failure_reason": {
"description": "Only with success false.",
"enum": [
"did_not_install",
"incompatible_environment",
"wrong_result",
"incomplete_result",
"too_slow",
"too_expensive",
"not_applicable_to_task",
"crashed",
"other"
],
"type": "string"
},
"latency_ms": {
"description": "Wall-clock time of the run in milliseconds.",
"minimum": 0,
"type": "integer"
},
"model": {
"description": "The model you run on, e.g. claude-sonnet-5. Savings are reported only for measured models.",
"type": "string"
},
"purchase_ref": {
"description": "The purchase_ref from unlock_capability, if you bought the capability.",
"pattern": "^pu_[a-z2-7]{26}$",
"type": "string"
},
"success": {
"description": "Whether the task reached its goal.",
"type": "boolean"
},
"tokens_in": {
"description": "Input tokens the run used.",
"minimum": 0,
"type": "integer"
},
"tokens_out": {
"description": "Output tokens the run used.",
"minimum": 0,
"type": "integer"
},
"tool_calls": {
"description": "Tool calls the run made.",
"minimum": 0,
"type": "integer"
},
"used_capability": {
"description": "Whether the capability was used in this run; false reports a run done without it.",
"type": "boolean"
}
},
"required": [
"capability",
"success"
],
"type": "object"
},
"name": "report_outcome",
"outputSchema": null
},
{
"description": "Describe a task in plain words and get one compact answer: whether a registry capability is worth using for it, from registry-run benchmarks only, and the next step. Use when: you have a task and no capability name, and want one decision word (use, do_not_use, use_free_alternative, insufficient_evidence, blocked_by_constraints or no_match) with its reason codes. Not for: the full arithmetic, the offer and the operator message (evaluate_capability with the same inputs), a plain list of matches (search_capabilities) or a capability you can already name (get_capability). Input: task, plus optional model, expected_runs, baseline_cost_estimate_usd, context and constraints; any other field is refused with the allowed list. Output: ak.resolve.v1 with decision, capability id, reason codes, the measured saving per run with its interval or null, the estimate at your own baseline with its break-even runs or null, confidence, evidence label, price, free alternatives, next action, evaluation_id and the tool that gives the detail. do_not_use and no_match are normal answers.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"baseline_cost_estimate_usd": {
"description": "What one run of this task costs you today without the capability, in USD.",
"exclusiveMinimum": 0,
"type": "number"
},
"constraints": {
"additionalProperties": false,
"description": "Limits you set for the answer; a capability outside them is reported as blocked, with the reason code.",
"properties": {
"max_cost_usd": {
"description": "The highest price in USD you accept; a capability priced above it is blocked (over_max_cost).",
"minimum": 0,
"type": "number"
},
"minimum_confidence": {
"description": "The lowest confidence in the measured saving you accept, from 0.5 to 0.999 (default 0.9); below it the answer is blocked (below_minimum_confidence).",
"maximum": 0.999,
"minimum": 0.5,
"type": "number"
}
},
"type": "object"
},
"context": {
"additionalProperties": {
"type": [
"string",
"number",
"integer",
"boolean"
]
},
"description": "Facts about your situation, keyed by the capability's parameter names (e.g. log_lines).",
"type": "object"
},
"expected_runs": {
"description": "How many times you expect to perform this kind of task.",
"minimum": 1,
"type": "integer"
},
"model": {
"description": "The model you run on, e.g. claude-sonnet-5. Savings are reported only for measured models.",
"type": "string"
},
"task": {
"description": "Plain description of the task you are about to do (at most 4000 characters).",
"type": "string"
}
},
"required": [
"task"
],
"type": "object"
},
"name": "resolve_task",
"outputSchema": null
},
{
"description": "Search capability names, summaries, tasks and use-when conditions by keywords, ranked by lexical relevance only, never by payment. Use when: you want to see which capabilities exist for a topic, or you know part of a name. Not for: deciding whether one fits your task (resolve_task, or evaluate_capability for the full arithmetic) or reading a capability you can already name (get_capability). Input: search words, at most 500 characters; no earlier call is needed. Output: ak.search.v1 with id, name, summary, relevance, state, price and the strongest evidence label of each result, and no decision.",
"inputSchema": {
"properties": {
"limit": {
"description": "How many results to return, from 1 to 50 (default 10).",
"maximum": 50,
"minimum": 1,
"type": "integer"
},
"query": {
"description": "Search words (at most 500 characters).",
"type": "string"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "search_capabilities",
"outputSchema": null
},
{
"description": "Exchange the license key from the checkout (a purchase requires operator approval) for a signed entitlement and a download link that lasts at most 15 minutes. How the key is handled: the privacy page at /legal/privacy/. Repeating it with the same key is safe and never charges. Use when: your operator completed the hosted checkout and gave you the license key. Not for: a price or a checkout link (get_quote); a free capability downloads from its page. Input: the capability id and the license key, plus quote_id and evaluation_id when you have them. Output: a signed entitlement, a purchase_ref for report_outcome and the download link.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"capability": {
"description": "Capability id (ak:publisher:name or ak:publisher:name:x.y.z), ak:// URI or slug.",
"type": "string"
},
"evaluation_id": {
"description": "The evaluation_id from evaluate_capability, if you evaluated first.",
"pattern": "^ev_[a-z2-7]{26}$",
"type": "string"
},
"license_key": {
"description": "License key from the checkout.",
"type": "string"
},
"quote_id": {
"description": "The quote_id of the quote the purchase followed, if any (links the records; never changes the price).",
"type": "string"
}
},
"required": [
"capability",
"license_key"
],
"type": "object"
},
"name": "unlock_capability",
"outputSchema": null
}
]
}Verify it yourself
curl -s https://api.teppi.xyz/v1/evidence/sha256:16758e29d88585c079ef348f090adaf1039e59272a861dea20bebaf74a7283a3 | sha256sum