Connect

8 clients · secrets stay placeholders

JSON (mcpServers)Claude CodeCodexOpenCodeCursorVS CodeGemini CLIGoose

{
  "mcpServers": {
    "skeletable": {
      "type": "http",
      "url": "https://skeletable.com/mcp"
    }
  }
}

claude mcp add --transport http skeletable https://skeletable.com/mcp

[mcp_servers.skeletable]
url = "https://skeletable.com/mcp"

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "skeletable": {
      "type": "remote",
      "url": "https://skeletable.com/mcp",
      "enabled": true
    }
  }
}

{
  "mcpServers": {
    "skeletable": {
      "type": "http",
      "url": "https://skeletable.com/mcp"
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=skeletable&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vc2tlbGV0YWJsZS5jb20vbWNwIn0%3D"
}

{
  "servers": {
    "skeletable": {
      "type": "http",
      "url": "https://skeletable.com/mcp"
    }
  }
}

{
  "mcpServers": {
    "skeletable": {
      "httpUrl": "https://skeletable.com/mcp"
    }
  }
}

extensions:
  "skeletable":
    enabled: true
    name: "skeletable"
    type: streamable_http
    uri: "https://skeletable.com/mcp"
    timeout: 300

Quality 89 / 100new

protocol75 · weight 25

warn
protocol.modernnewest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
n/a
protocol.statelessonly applies to 2026-07-28 servers
pass
protocol.transportstreamable HTTP
n/a
protocol.list_ttlonly applies to 2026-07-28 servers

authorizationn/a · weight 15

n/a
auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
n/a
auth.secret_in_urlno templated URL

tool hygiene100 · weight 30

pass
tools.descriptionsevery tool has a description
pass
tools.description_lengthdescriptions are concise
pass
tools.schemasevery tool has an object input schema
pass
tools.annotations16 of 16 tools declare readOnlyHint or destructiveHint
pass
tools.directory_hintsevery tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
pass
tools.token_costabout 4,532 tokens to load every tool
pass
tools.api_dumptools are not a one-to-one API dump

stabilityn/a · weight 15

n/a
stability.changes, stability.rug_pulltool history recorded for 5 of the 7 days needed

dependenciesn/a · weight 15

n/a
deps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI package

16 tools, about 4,532 tokens to load them all · tool set ea0f09bdfdb7 · tools last changed 2026-11-02 · checked 2026-11-07 17:28 UTC

Tool changes

2026-11-02create_tablechangedinput schema
2026-11-02fill_ai_cellsadded
Save up to 200 answers to an AI column, each with the `row` and `basis` next_ai_cells gave it. An answer outside the column's choices, or to a prompt that has since changed, comes back with a reason. Each value is saved as generated, with the instruction and `model`. Needs a token.
2026-11-02next_ai_cellsadded
The next prompts to answer for a table's AI columns, up to 200 at a time: blank cells first, then answers whose row or instruction has changed. Answer each prompt yourself, then send the answers back with fill_ai_cells, each with its `row` and `basis`. Repeat until it says `done`. `redo` also re-answers generated values that came from outside the instruction. Needs a token.
2026-11-02set_instructionadded
Make a column an AI column, change its instruction, or turn it back into a plain column with an empty one. The instruction says what to work out for each row and names other columns in braces, like "Classify {Pitch} by genre". Its values never overwrite what a person typed, linked or quoted. Needs proof to be optional and a token.
2026-11-02fork_tableadded
Copy a table into your own account as a private draft, to extend or relabel: any published public table, or one you run. Every value keeps its proof or origin, and the copy remembers where it came from. Needs a token.
2026-11-02save_versionadded
Freeze a table you run as it stands now, as a numbered version with a lasting link that never changes. Do this before training on a dataset or citing a table, and name the version you used. Needs a token.
2026-11-02data_linkadded
A private address that loads a table you run as CSV, for a notebook, a script or a spreadsheet, with the lines to do it. Add `?columns=a,b` to pick columns and `?names=0` to leave out row names. Anyone with the link can read the data, and `fresh` makes a new one so the old one stops working. Needs a token.
2026-11-02fill_cellschangeddescription, input schemameaning changed
before
Fill up to 25 cells of a draft you run. Each cell gives `value`, `source` and `quote`, where the quote is word for word from the source and states the value; each is checked and the page opened before it's saved. If no acceptable source states it, give `checked` with the pages you read instead of a value, and add `none_stated` only if you read the whole source and it has no such value. Bad cells come back with a reason and don't stop the rest. Needs a token.
after · 41% of words in common
Set up to 200 cells of a table you run. Usually a cell gives `value` and `origin` (`entered`, `imported` with a `note` like the file or email it came from, `link` with its `source`, or `generated`). Left out, the origin is `link` when there's a `source` and `generated` when there isn't. These can go into a published table too, and never replace a quoted value. A date is written YYYY-MM-DD, and a column with choices takes only one of them. In a table that requires proof, a cell instead gives `value`, `source` and `quote`, word for word from the source; each page is opened before it's saved, so send at most 25 of these at once, and only into a draft. If no acceptable source states it, give `checked` with the pages you read, and `none_stated` only if you read the whole source and it has no such value. The reply counts what saved and lists only the cells that didn't, with a reason, and `unchecked` names quoted values whose page couldn't be read. Needs a token.
2026-11-02add_rowschangeddescription, input schemameaning changed
before
Add rows to a draft you run, as you find what belongs in it. A name it already has is skipped. Needs a token.
after · 19% of words in common
Add up to 500 rows to a table you run. Each row is a name, or an object with its `values` by column id or label, so a whole tracker or dataset goes in a few calls. A row without a `key` gets the next free number. A name the table already has gets the values given for it, so syncing again from the same source is one call; with no values it's skipped. Say where the values came from with `origin` (`entered`, `imported` with a `note` naming the file or email, `link` with a `source`, or `generated`, which is the default without a source). Rows with values can go into a published table too; rows by name only into a draft. A table that requires proof takes rows by name only. Needs a token.
2026-11-02add_columnschangedinput schema

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.

Trust 97 / 100

provenance90

liveness100

freshness100

hygiene100

+repository +namespace-matches-repo +website +reachable +uptime-100% +updated-6d-ago

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Endpoints

remote	auth	reachable	uptime 30d	p50	protocol	last ok
`https://skeletable.com/mcp` streamable-http	none	yes	100%	335 ms	2025-11-25	2026-11-07

Tools (16)

`add_columns`	Add columns to a draft you run, such as a blank one a person started. Returns the new column ids for fill_cells. Needs a token.
`add_rows`	Add up to 500 rows to a table you run. Each row is a name, or an object with its `values` by column id or label, so a whole tracker or dataset goes in a few calls. A row without a `key` gets the next free number. A name the table already has gets the values given for it, so syncing again from the same source is one call; with no values it's skipped. Say where the values came from with `origin` (`entered`, `imported` with a `note` naming the file or email, `link` with a `source`, or `generated`, which is the default without a source). Rows with values can go into a published table too; rows by name only into a draft. A table that requires proof takes rows by name only. Needs a token.
`check_claim`read-only	Test a statement against one cell, such as whether a value in a draft or an answer is right. The verdict is `matches`, `differs` (with what the source states), `disputed` (sources disagree, see `conflicts`) or `unknown` (no acceptable source stated it, so say so). It compares values and doesn't judge meaning, so read the quote before relying on a text verdict. Use list_tables and get_table to find the cell first.
`create_table`	Make a private draft table, ready to fill, for anything from a tracker to a dataset. Its values say where they came from unless you set `proof` to `required`. Only `title`, `columns` and `rows` are needed now, but give `question`, `scope`, and a `rule` for each column if you can: a person has to supply them before publishing. Returns the column ids fill_cells needs, and the sheet's link, so tell your person to open it and watch it fill. Needs a token.
`data_link`	A private address that loads a table you run as CSV, for a notebook, a script or a spreadsheet, with the lines to do it. Add `?columns=a,b` to pick columns and `?names=0` to leave out row names. Anyone with the link can read the data, and `fresh` makes a new one so the old one stops working. Needs a token.
`export_table`read-only	A table as CSV, ready to save as a file or load into a notebook. The first column is each row's name unless `names` is false. `columns` picks columns by id, in that order. With `proof`, each column is followed by its source and quote, and in a table whose proof is optional, by where each value came from. An empty field means no value.
`fill_ai_cells`	Save up to 200 answers to an AI column, each with the `row` and `basis` next_ai_cells gave it. An answer outside the column's choices, or to a prompt that has since changed, comes back with a reason. Each value is saved as generated, with the instruction and `model`. Needs a token.
`fill_cells`	Set up to 200 cells of a table you run. Usually a cell gives `value` and `origin` (`entered`, `imported` with a `note` like the file or email it came from, `link` with its `source`, or `generated`). Left out, the origin is `link` when there's a `source` and `generated` when there isn't. These can go into a published table too, and never replace a quoted value. A date is written YYYY-MM-DD, and a column with choices takes only one of them. In a table that requires proof, a cell instead gives `value`, `source` and `quote`, word for word from the source; each page is opened before it's saved, so send at most 25 of these at once, and only into a draft. If no acceptable source states it, give `checked` with the pages you read, and `none_stated` only if you read the whole source and it has no such value. The reply counts what saved and lists only the cells that didn't, with a reason, and `unchecked` names quoted values whose page couldn't be read. Needs a token.
`fork_table`	Copy a table into your own account as a private draft, to extend or relabel: any published public table, or one you run. Every value keeps its proof or origin, and the copy remembers where it came from. Needs a token.
`get_cell`read-only	The evidence for one value: the source, the exact quote, what kind of source it is and when it was read. For a missing value, where we looked, and `absent` means the source was read and gives no such value. `url` is the cell's lasting address, showing its proof, for citing. `confirmed` says how a second reader backed it up, and without it the value has been read once. `conflicts` lists sources that state something else, `history` lists past values, and `watch` says whether the quote was still on its page at the last check.
`get_table`read-only	Read a table: its scope, its columns with the rule for each, a summary of what each column holds, and its rows. A null value is blank. `origins` says where a row's unquoted values came from, `ai` says how far each AI column has got, and `versions` lists saved versions. For a big table, read the summaries first and page through rows with `offset` and `limit`.
`list_tables`read-only	Find tables in the library. Each result gives its slug, the question it answers, its size and when it was last read.
`next_ai_cells`read-only	The next prompts to answer for a table's AI columns, up to 200 at a time: blank cells first, then answers whose row or instruction has changed. Answer each prompt yourself, then send the answers back with fill_ai_cells, each with its `row` and `basis`. Repeat until it says `done`. `redo` also re-answers generated values that came from outside the instruction. Needs a token.
`propose_change`	Suggest a new value for a cell, with its proof. The quote must be word for word from the source and state the value. The owner reviews it before anything changes. Needs a token sent as a Bearer token.
`save_version`	Freeze a table you run as it stands now, as a numbered version with a lasting link that never changes. Do this before training on a dataset or citing a table, and name the version you used. Needs a token.
`set_instruction`	Make a column an AI column, change its instruction, or turn it back into a plain column with an empty one. The instruction says what to work out for each row and names other columns in braces, like "Classify {Pitch} by genre". Its values never overwrite what a person typed, linked or quoted. Needs proof to be optional and a token.

Schemas: list_tools.

Similar MCP servers

Official server.json

{
  "name": "io.github.eftpmc/skeletable",
  "icons": [
    {
      "src": "https://skeletable.com/logo.png",
      "mimeType": "image/png"
    }
  ],
  "title": "Skeletable",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://skeletable.com/mcp",
      "type": "streamable-http"
    }
  ],
  "version": "1.0.0",
  "repository": {
    "url": "https://github.com/eftpmc/skeletable",
    "source": "github"
  },
  "websiteUrl": "https://skeletable.com/developers",
  "description": "Source-backed public tables with citations, claim checks, and reviewable corrections."
}