Search / ac.inference.sh/mcp
protogridR0· no sign-inrun any ai model. compose agents, stack knowledge, connect tools. one api, pay per run.
v2.0.1 · active · descriptor JSON · versions
{
"mcpServers": {
"sh": {
"type": "http",
"url": "https://api.inference.sh/mcp"
}
}
}claude mcp add --transport http sh https://api.inference.sh/mcp[mcp_servers.sh]
url = "https://api.inference.sh/mcp"
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"sh": {
"type": "remote",
"url": "https://api.inference.sh/mcp",
"enabled": true
}
}
}{
"mcpServers": {
"sh": {
"type": "http",
"url": "https://api.inference.sh/mcp"
}
},
"deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=sh&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vYXBpLmluZmVyZW5jZS5zaC9tY3AifQ%3D%3D"
}{
"servers": {
"sh": {
"type": "http",
"url": "https://api.inference.sh/mcp"
}
}
}{
"mcpServers": {
"sh": {
"httpUrl": "https://api.inference.sh/mcp"
}
}
}extensions:
"sh":
enabled: true
name: "sh"
type: streamable_http
uri: "https://api.inference.sh/mcp"
timeout: 300
protocol.modernsupports 2026-07-28 (server/discover)protocol.statelessanswers without a sessionprotocol.transportstreamable HTTPprotocol.list_ttltool list is cacheable (ttlMs 300000)auth.prm, auth.as_metadata, auth.cimdno remote uses OAuthauth.secret_in_urlno templated URLtools.descriptionsevery tool has a descriptiontools.description_length1 tools have descriptions over 1,024 characters, which crowds the contexttools.schemasevery tool has an object input schematools.annotations46 of 46 tools declare readOnlyHint or destructiveHinttools.directory_hintsno tool declares all four of readOnlyHint, destructiveHint, idempotentHint and openWorldHint; missing: app_get (idempotentHint, openWorldHint); app_list (idempotentHint, openWorldHint); app_run (idempotentHint); …tools.token_costabout 8,153 tokens to load every tooltools.api_dumptools are not a one-to-one API dumpstability.changes74 tool changes in 30 daysstability.rug_pull1 tools kept their name but changed most of their description in 30 days; review before trusting themdeps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI packagetask_listchangedinput schemaartifact_data_updatechangedinput schemaartifact_data_setchangedinput schemaartifact_data_listchangedinput schemaartifact_data_getchangedinput schemaartifact_data_deletechangedinput schemaartifact_publishchangeddescription, input schemaPublish a self-contained HTML(+JS) or Markdown page as an artifact: a live page at a private URL that can be shared with a team, an org, or publicly, and that updates in place when published again. Pass artifact_id (or reuse the same name) to publish a new version. Returns the artifact id, url, and version. ## Before you write the page Load the skill for what you are about to build, with whichever skill tool this session has (`skill_get`, `skill_use`, or `belt skill use infsh/<name>`): - `belt-artifact-design` — always. Treatment, the injected design tokens, the three theme states, the traps that fail silently. - `belt-artifact-capabilities` — when the page takes input, remembers anything, knows who is viewing, or shows a file stored beside it. - `belt-artifact-diagrams` — when it has a flow, an architecture, a timeline or a chart. They are the current version at all times. This description is only the contract. ## When to use an artifact Use one when terminal text is the wrong medium: a dashboard from data you already pulled, a walkthrough of a change with annotated diffs, several options side by side, sliders to tune values, a checklist you keep updating while a long task runs, or anything a person will look at, interact with, or send to a teammate as a link. Don't use one for a short answer, a code snippet, or advice the user will act on immediately in the terminal. ## Page contract - Write the PAGE CONTENT only. It is wrapped at publish time in <!doctype html> + <head> (charset, viewport, <title>, favicon, a reset, and the inference.sh design tokens) + <body>. Put your own <style> and <script> at the top of the content. A full document (starting with <!doctype> or <html>) is accepted too and keeps its own <head>. - Everything must be self-contained: inline all CSS and JS, embed images as data: URIs, draw diagrams as mermaid, inline SVG or HTML/CSS. There is no backend, no routes, no relative links; use in-page anchors. - CSP allowlist (enforced, failures are silent): external scripts ONLY from https://cdnjs.cloudflare.com, https://cdn.jsdelivr.net/npm/, https://cdn.tailwindcss.com, https://code.jquery.com; external stylesheets ONLY from https://fonts.googleapis.com with the font files they pull from https://fonts.gstatic.com. Every other host is blocked, and so is fetch/XHR/WebSocket to anywhere. Load libraries as pinned UMD builds, e.g. <script src="https://cdnjs.cloudflare.com/ajax/libs/react/18.3.1/umd/react.production.min.js"></script>, placed BEFORE the inline script that uses them. - A page may also be shown inside an MCP Apps host (Claude, the chat). Those hosts grant a narrower policy than the inference.sh viewer: no eval or new Function, no data: fonts, no blob: images or media. A page that needs any of them works in the viewer and breaks there, so inline fonts as files stored beside the page (the "assets" capability) and avoid libraries that compile code at runtime. - Size: the source must be under 16 MiB. Prefer SVG and CSS over embedded raster images; summarize large datasets instead of inlining them. - Markdown: set type "markdown" for a document-shaped page; it is rendered with GitHub-flavored markdown and a readable default typography. - Diagrams: a flow, sequence, state or class diagram can be written as mermaid — a ```mermaid fence in Markdown, or <pre class="mermaid">...</pre> in HTML. The renderer adds mermaid 11.15.0 and themes it from the design tokens, and only for a page that has one. Everything else is inline SVG or CSS. - Title: a short, distinctive noun phrase (2-4 words) that names the page, not a summary and not a category label. Favicon: one or two emoji. Keep both stable across updates. ## Runtime capabilities A page is static by default and cannot reach the network at all. Declare a capability at publish time and the page gets a window.inferencesh object. Declare only what the page actually calls; a page gets nothing it did not declare. Every call goes through the viewer's own session, s
Publish a self-contained HTML(+JS) or Markdown page as an artifact: a live page at a private URL that can be shared with a team, an org, or publicly, and that updates in place when published again. Pass artifact_id (or reuse the same name) to publish a new version. Returns the artifact id, url, and version. ## Before you write the page Load the skill for what you are about to build, with whichever skill tool this session has (`skill_get`, `skill_use`, or `belt skill use infsh/<name>`): - `belt-artifact-design` — always. Treatment, the injected design tokens, the three theme states, the traps that fail silently. - `belt-artifact-capabilities` — when the page takes input, remembers anything, knows who is viewing, or shows a file stored beside it. - `belt-artifact-diagrams` — when it has a flow, an architecture, a timeline or a chart. They are the current version at all times. This description is only the contract. ## When to use an artifact Use one when terminal text is the wrong medium: a dashboard from data you already pulled, a walkthrough of a change with annotated diffs, several options side by side, sliders to tune values, a checklist you keep updating while a long task runs, or anything a person will look at, interact with, or send to a teammate as a link. Don't use one for a short answer, a code snippet, or advice the user will act on immediately in the terminal. ## Page contract - Write the PAGE CONTENT only. It is wrapped at publish time in <!doctype html> + <head> (charset, viewport, <title>, favicon, a reset, and the inference.sh design tokens) + <body>. Put your own <style> and <script> at the top of the content. A full document (starting with <!doctype> or <html>) is accepted too and keeps its own <head>. - Everything must be self-contained: inline CSS and JS or ship them as files, embed images as data: URIs, draw diagrams as mermaid, inline SVG or HTML/CSS. A page may ship extra files (pages, css, js, json) via `files`: link between pages with relative links (`pricing` or `pricing.html`, served at the same origin) and fetch its own json with relative URLs. There is still no backend. - CSP allowlist (enforced, failures are silent): external scripts ONLY from https://cdnjs.cloudflare.com, https://cdn.jsdelivr.net/npm/, https://cdn.tailwindcss.com, https://code.jquery.com; external stylesheets ONLY from https://fonts.googleapis.com with the font files they pull from https://fonts.gstatic.com. Every other host is blocked, and so is fetch/XHR/WebSocket to anywhere but the page's own files. Load libraries as pinned UMD builds, e.g. <script src="https://cdnjs.cloudflare.com/ajax/libs/react/18.3.1/umd/react.production.min.js"></script>, placed BEFORE the inline script that uses them. - A page may also be shown inside an MCP Apps host (Claude, the chat). Those hosts grant a narrower policy than the inference.sh viewer: no eval or new Function, no data: fonts, no blob: images or media. A page that needs any of them works in the viewer and breaks there, so inline fonts as files stored beside the page (the "assets" capability) and avoid libraries that compile code at runtime. - Size: the source must be under 16 MiB. Prefer SVG and CSS over embedded raster images; summarize large datasets instead of inlining them. - Markdown: set type "markdown" for a document-shaped page; it is rendered with GitHub-flavored markdown and a readable default typography. - Diagrams: a flow, sequence, state or class diagram can be written as mermaid — a ```mermaid fence in Markdown, or <pre class="mermaid">...</pre> in HTML. The renderer adds mermaid 11.15.0 and themes it from the design tokens, and only for a page that has one. Everything else is inline SVG or CSS. - Title: a short, distinctive noun phrase (2-4 words) that names the page, not a summary and not a category label. Favicon: one or two emoji. Keep both stable across updates. ## Runtime capabilities A page is static by default and cannot reach the network at all. Declare a capabil
artifact_publishchangeddescriptionPublish a self-contained HTML(+JS) or Markdown page as an artifact: a live page at a private URL that can be shared with a team, an org, or publicly, and that updates in place when published again. Pass artifact_id (or reuse the same name) to publish a new version. Returns the artifact id, url, and version. ## Before you write the page Load the skill for what you are about to build, with whichever skill tool this session has (`skill_get`, `skill_use`, or `belt skill use infsh/<name>`): - `belt-artifact-design` — always. Treatment, the injected design tokens, the three theme states, the traps that fail silently. - `belt-artifact-capabilities` — when the page takes input, remembers anything, knows who is viewing, or shows a file stored beside it. - `belt-artifact-diagrams` — when it has a flow, an architecture, a timeline or a chart. They are the current version at all times. This description is only the contract. ## When to use an artifact Use one when terminal text is the wrong medium: a dashboard from data you already pulled, a walkthrough of a change with annotated diffs, several options side by side, sliders to tune values, a checklist you keep updating while a long task runs, or anything a person will look at, interact with, or send to a teammate as a link. Don't use one for a short answer, a code snippet, or advice the user will act on immediately in the terminal. ## Page contract - Write the PAGE CONTENT only. It is wrapped at publish time in <!doctype html> + <head> (charset, viewport, <title>, favicon, a reset, and the inference.sh design tokens) + <body>. Put your own <style> and <script> at the top of the content. A full document (starting with <!doctype> or <html>) is accepted too and keeps its own <head>. - Everything must be self-contained: inline all CSS and JS, embed images as data: URIs, draw diagrams as mermaid, inline SVG or HTML/CSS. There is no backend, no routes, no relative links; use in-page anchors. - CSP allowlist (enforced, failures are silent): external scripts ONLY from https://cdnjs.cloudflare.com, https://cdn.jsdelivr.net/npm/, https://cdn.tailwindcss.com, https://code.jquery.com; external stylesheets ONLY from https://fonts.googleapis.com with the font files they pull from https://fonts.gstatic.com. Every other host is blocked, and so is fetch/XHR/WebSocket to anywhere. Load libraries as pinned UMD builds, e.g. <script src="https://cdnjs.cloudflare.com/ajax/libs/react/18.3.1/umd/react.production.min.js"></script>, placed BEFORE the inline script that uses them. - A page may also be shown inside an MCP Apps host (Claude, the chat). Those hosts grant a narrower policy than the inference.sh viewer: no eval or new Function, no data: fonts, no blob: images or media. A page that needs any of them works in the viewer and breaks there, so inline fonts as files stored beside the page (the "assets" capability) and avoid libraries that compile code at runtime. - Size: the source must be under 16 MiB. Prefer SVG and CSS over embedded raster images; summarize large datasets instead of inlining them. - Markdown: set type "markdown" for a document-shaped page; it is rendered with GitHub-flavored markdown and a readable default typography. - Diagrams: a flow, sequence, state or class diagram can be written as mermaid — a ```mermaid fence in Markdown, or <pre class="mermaid">...</pre> in HTML. The renderer adds mermaid 11.15.0 and themes it from the design tokens, and only for a page that has one. Everything else is inline SVG or CSS. - Title: a short, distinctive noun phrase (2-4 words) that names the page, not a summary and not a category label. Favicon: one or two emoji. Keep both stable across updates. ## Runtime capabilities A page is static by default and cannot reach the network at all. Declare a capability at publish time and the page gets a window.inferencesh object. Declare only what the page actually calls; a page gets nothing it did not declare. Every call goes through the viewer's own session, s
Publish a self-contained HTML(+JS) or Markdown page as an artifact: a live page at a private URL that can be shared with a team, an org, or publicly, and that updates in place when published again. Pass artifact_id (or reuse the same name) to publish a new version. Returns the artifact id, url, and version. ## Before you write the page Load the skill for what you are about to build, with whichever skill tool this session has (`skill_get`, `skill_use`, or `belt skill use infsh/<name>`): - `belt-artifact-design` — always. Treatment, the injected design tokens, the three theme states, the traps that fail silently. - `belt-artifact-capabilities` — when the page takes input, remembers anything, knows who is viewing, or shows a file stored beside it. - `belt-artifact-diagrams` — when it has a flow, an architecture, a timeline or a chart. They are the current version at all times. This description is only the contract. ## When to use an artifact Use one when terminal text is the wrong medium: a dashboard from data you already pulled, a walkthrough of a change with annotated diffs, several options side by side, sliders to tune values, a checklist you keep updating while a long task runs, or anything a person will look at, interact with, or send to a teammate as a link. Don't use one for a short answer, a code snippet, or advice the user will act on immediately in the terminal. ## Page contract - Write the PAGE CONTENT only. It is wrapped at publish time in <!doctype html> + <head> (charset, viewport, <title>, favicon, a reset, and the inference.sh design tokens) + <body>. Put your own <style> and <script> at the top of the content. A full document (starting with <!doctype> or <html>) is accepted too and keeps its own <head>. - Everything must be self-contained: inline all CSS and JS, embed images as data: URIs, draw diagrams as mermaid, inline SVG or HTML/CSS. There is no backend, no routes, no relative links; use in-page anchors. - CSP allowlist (enforced, failures are silent): external scripts ONLY from https://cdnjs.cloudflare.com, https://cdn.jsdelivr.net/npm/, https://cdn.tailwindcss.com, https://code.jquery.com; external stylesheets ONLY from https://fonts.googleapis.com with the font files they pull from https://fonts.gstatic.com. Every other host is blocked, and so is fetch/XHR/WebSocket to anywhere. Load libraries as pinned UMD builds, e.g. <script src="https://cdnjs.cloudflare.com/ajax/libs/react/18.3.1/umd/react.production.min.js"></script>, placed BEFORE the inline script that uses them. - A page may also be shown inside an MCP Apps host (Claude, the chat). Those hosts grant a narrower policy than the inference.sh viewer: no eval or new Function, no data: fonts, no blob: images or media. A page that needs any of them works in the viewer and breaks there, so inline fonts as files stored beside the page (the "assets" capability) and avoid libraries that compile code at runtime. - Size: the source must be under 16 MiB. Prefer SVG and CSS over embedded raster images; summarize large datasets instead of inlining them. - Markdown: set type "markdown" for a document-shaped page; it is rendered with GitHub-flavored markdown and a readable default typography. - Diagrams: a flow, sequence, state or class diagram can be written as mermaid — a ```mermaid fence in Markdown, or <pre class="mermaid">...</pre> in HTML. The renderer adds mermaid 11.15.0 and themes it from the design tokens, and only for a page that has one. Everything else is inline SVG or CSS. - Title: a short, distinctive noun phrase (2-4 words) that names the page, not a summary and not a category label. Favicon: one or two emoji. Keep both stable across updates. ## Runtime capabilities A page is static by default and cannot reach the network at all. Declare a capability at publish time and the page gets a window.inferencesh object. Declare only what the page actually calls; a page gets nothing it did not declare. Every call goes through the viewer's own session, s
task_getchangedinput schemaapp_runchangeddescriptionRun an app on inference.sh. Creates a task that executes the app with the given input. When the result's status is not final, the task is still running: call task_get with wait: true for its output.
Run an app on inference.sh. Creates a task that executes the app with the given input. When the result's status is not final, the task is still running: call task_get with wait: true when you need its output.
Showing the latest 10. Full history: list_changes · trend: quality JSON.
Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.
+dns-namespace +reachable +uptime-99% ~updated-85d-ago -no-repository
Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.
| remote | auth | reachable | uptime 30d | p50 | protocol | last ok |
|---|---|---|---|---|---|---|
https://api.inference.sh/mcp streamable-http | none | yes | 99% | 695 ms | 2026-07-28, 2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05 | 2026-10-20 |
app_getread-only | Get detailed app info including input/output schemas and version history |
app_listread-only | Search and filter available apps on inference.sh |
app_run | Run an app on inference.sh. Creates a task that executes the app with the given input. When the result's status is not final, the task is still running: call task_get with wait: true when you need its output. |
artifact_asset_deletedestructive | Permanently delete one file stored beside an artifact. Anything on the page still pointing at it stops loading, so delete only a file nothing references. |
artifact_asset_listread-only | List the files stored beside an artifact, with the URL each is referenced by and what the artifact is using against its budget. |
artifact_asset_upload | Store an image, video, audio file, font or PDF beside an artifact and get back the URL its page references it by. Use this instead of a data: URI for anything sizeable: a data URI costs a third more than the bytes it carries, and a page has a 16 MiB ceiling. The page must be published with the "assets" capability or its CSP will refuse to load the file. Uploading the same bytes twice returns the asset already there. |
artifact_commentsread-only | Read the comment threads people left on an artifact. Each thread says whether it was sent to you: you may reply to and resolve those, and only those. Threads not sent to you are other people's conversations — read them for context, mention them to the user if they need action, but do not answer them. |
artifact_data_deletedestructive | Removes one document from an artifact's store, as the page runtime's db.delete. |
artifact_data_getread-only | Reads one document from an artifact's store, as the page runtime's db.get. |
artifact_data_listread-only | Lists a collection in an artifact's store, as the page runtime's db.list. |
artifact_data_set | Replaces one document in an artifact's store, as the page runtime's db.set. |
artifact_data_update | Merges into one document in an artifact's store, as the page runtime's db.update. |
artifact_getread-only | Get an artifact's metadata and page source by id, short id, or namespace/name[@version] |
artifact_guidanceread-only | Everything needed to write a good artifact page, assembled in one call: the page contract plus the skills that carry the detail, resolved from the registry so they are always the current version. Call this BEFORE writing a page. Narrow it with topics; omit topics for all of them. |
artifact_listread-only | List artifacts you own or that were shared with you, newest first |
artifact_publish | Publish a self-contained HTML(+JS) or Markdown page as an artifact: a live page at a private URL that can be shared with a team, an org, or publicly, and that updates in place when published again. Pass artifact_id (or reuse the same name) to publish a new version. Returns the artifact id, url, and version. ## Before you write the page Load the skill for what you are about to build, with whichever skill tool this session has (`skill_get`, `skill_use`, or `belt skill use infsh/<name>`): - `belt-artifact-design` — always. Treatment, the injected design tokens, the three theme states, the traps that fail silently. - `belt-artifact-capabilities` — when the page takes input, remembers anything, knows who is viewing, or shows a file stored beside it. - `belt-artifact-diagrams` — when it has a flow, an architecture, a timeline or a chart. They are the current version at all times. This description is only the contract. ## When to use an artifact Use one when terminal text is the wrong medium: a dashboard from data you already pulled, a walkthrough of a change with annotated diffs, several options side by side, sliders to tune values, a checklist you keep updating while a long task runs, or anything a person will look at, interact with, or send to a teammate as a link. Don't use one for a short answer, a code snippet, or advice the user will act on immediately in the terminal. ## Page contract - Write the PAGE CONTENT only. It is wrapped at publish time in <!doctype html> + <head> (charset, viewport, <title>, favicon, a reset, and the inference.sh design tokens) + <body>. Put your own <style> and <script> at the top of the content. A full document (starting with <!doctype> or <html>) is accepted too and keeps its own <head>. - Everything must be self-contained: inline CSS and JS or ship them as files, embed images as data: URIs, draw diagrams as mermaid, inline SVG or HTML/CSS. A page may ship extra files (pages, css, js, json) via `files`: link between pages with relative links (`pricing` or `pricing.html`, served at the same origin) and fetch its own json with relative URLs. There is still no backend. - CSP allowlist (enforced, failures are silent): external scripts ONLY from https://cdnjs.cloudflare.com, https://cdn.jsdelivr.net/npm/, https://cdn.tailwindcss.com, https://code.jquery.com; external stylesheets ONLY from https://fonts.googleapis.com with the font files they pull from https://fonts.gstatic.com. Every other host is blocked, and so is fetch/XHR/WebSocket to anywhere but the page's own files. Load libraries as pinned UMD builds, e.g. <script src="https://cdnjs.cloudflare.com/ajax/libs/react/18.3.1/umd/react.production.min.js"></script>, placed BEFORE the inline script that uses them. - A page may also be shown inside an MCP Apps host (Claude, the chat). Those hosts grant a narrower policy than the inference.sh viewer: no eval or new Function, no data: fonts, no blob: images or media. A page that needs any of them works in the viewer and breaks there, so inline fonts as files stored beside the page (the "assets" capability) and avoid libraries that compile code at runtime. - Size: the source must be under 16 MiB. Prefer SVG and CSS over embedded raster images; summarize large datasets instead of inlining them. - Markdown: set type "markdown" for a document-shaped page; it is rendered with GitHub-flavored markdown and a readable default typography. - Diagrams: a flow, sequence, state or class diagram can be written as mermaid — a ```mermaid fence in Markdown, or <pre class="mermaid">...</pre> in HTML. The renderer adds mermaid 11.15.0 and themes it from the design tokens, and only for a page that has one. Everything else is inline SVG or CSS. - Title: a short, distinctive noun phrase (2-4 words) that names the page, not a summary and not a category label. Favicon: one or two emoji. Keep both stable across updates. ## Runtime capabilities A page is static by default and cannot reach the network at all. Declare a capability at publish time and the page gets a window.inferencesh object. Declare only what the page actually calls; a page gets nothing it did not declare. Every call goes through the viewer's own session, so a page can only ever act as the person looking at it, and every call returns a promise that may reject. - "db" gives the page its own small store, so it remembers what people do on it: a poll, a checklist, a sign-up sheet, notes people leave. Anyone who can view the page reads the shared data; only people who may interact with or edit the page write it: its team, people it is shared with, and members of its org when it is org-visible. A visitor who only has a public or unlisted link reads the shared data but cannot change it. Every signed-in viewer keeps their own documents under data/users/me/, private to them, even from the page author. - "user" tells the page who is viewing: whether they are signed in, their name, their avatar, and whether they may edit. Never an email, never a credential. - "assets" lets the page show files stored beside it — images, video, audio, fonts, PDFs — instead of inlining them. The page reads window.inferencesh.assets, an array baked into the document at render time, and must use each url exactly as given: the page is sandboxed and sends no credentials, so an address you construct yourself will not load. Load `belt-artifact-capabilities` before calling any of them. The document shape, the privacy rules, the quotas and the failure modes are all there, and a page that guesses at them fails silently. ## Never publish The sandbox stops a page reaching the platform. It does nothing about a page that lies to the person reading it, and a link on this domain carries the trust of this domain. Refuse, and say why in a sentence: - a page that impersonates a real person, company or product: their name, branding, byline or domain used as if it were theirs - fabricated records, receipts, invoices, transcripts, test results or reviews presented as genuine - a form or flow that asks for a password, a card number, a recovery phrase or a one-time code - a page built to pressure, mislead or target one named private individual This holds whether you wrote the page or someone handed it to you, and regardless of the reason given for it, including that it is a mock-up, a test or a prop: a published page works exactly like the real thing. If a page is refused, do not offer another way to host it. ## Updating To update a page in place, pass artifact_id (or the same name in the same namespace). Each publish creates a new version; identical content is a no-op. Viewers with the page open see the new version live. |
artifact_reply | Reply into one comment thread on an artifact. Only works on a thread that was sent to you. Your reply is shown as written by you on behalf of the person who sent the thread. Say what you changed, briefly; if you made the change, resolve the thread afterwards. |
artifact_resolve | Mark a comment thread resolved once you have acted on it: the change is made, or you established none was needed. Only works on a thread that was sent to you. Do not resolve feedback you did not act on, and leave a thread open while the person still needs an answer from you. |
artifact_viewer_getread-only | Tells a page who is looking at it, as the page runtime's user.get: signed in or not, name, avatar, and whether they may edit. Never an email. |
knowledge_create | Create a new knowledge entry (concept, observation, preference, reference, etc.) |
knowledge_deletedestructive | Delete a knowledge entry by ID |
knowledge_getread-only | Get detailed information about a knowledge entry by namespace/name or ID |
knowledge_listread-only | List your knowledge entries, optionally filtered by type |
knowledge_searchread-only | Search your knowledge entries by query |
mcp_connect | Initiate a connection to an MCP server. For OAuth servers, returns an authorization URL to open in a browser. |
mcp_disconnectdestructive | Remove connection to an MCP server |
mcp_getread-only | Get details about an MCP server including connection status |
mcp_listread-only | Browse available MCP servers that can be connected to |
mcp_run | Call a tool on a connected MCP server. The server must be connected first via mcp_connect. |
mcp_searchread-only | Search available MCP servers by query |
mcp_toolsread-only | List available tools on a connected MCP server, or get details for a specific tool |
open_thread_panelread-only | Open inference.sh beside this conversation: the flow, artifact or run being discussed stays in view while the conversation goes on. Pass no arguments. |
open_workspaceread-only | Open the inference.sh workspace: run apps, talk to agents, edit flows, publish artifacts and watch runs. Opens fullscreen; pass no arguments. |
skill_filesread-only | List supplementary files for a skill (references, scripts, etc.) |
skill_searchread-only | Search the public skill store |
skill_storeread-only | Browse approved skills in the public skill store |
skill_upload | Create or update a skill with SKILL.md content and optional supporting files |
skill_useread-only | Fetch a skill's assembled SKILL.md content. Tries the inference.sh store first, falls back to GitHub. Returns the full skill content for the agent to consume. |
skill_viewread-only | View a specific supplementary file from a skill's manifest |
task_canceldestructive | Cancel a running or queued task |
task_getread-only | Get status and output of a task |
task_listread-only | List your tasks on inference.sh |
task_logsread-only | Get execution logs for a task |
workspace_focus | Record what the user is looking at in the workspace frame, so tools can default to it. Called by the workspace viewer on navigation and selection. |
workspace_session | Mint a short-lived session for the workspace frame, as the signed-in user and the connection's team. Replaces the previous one. Called by the workspace viewer, never by the model. |
workspace_session_end | Revoke the session minted for the workspace frame. Called by the workspace viewer when the panel closes, never by the model. |
Schemas: list_tools.
{
"name": "ac.inference.sh/mcp",
"title": "inference.sh",
"$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
"remotes": [
{
"url": "https://api.inference.sh/mcp",
"type": "streamable-http"
}
],
"version": "2.0.1",
"description": "run any ai model. compose agents, stack knowledge, connect tools. one api, pay per run."
}