# Skeletable

> Source-backed public tables with citations, claim checks, and reviewable corrections.

- name: io.github.eftpmc/skeletable
- version: 1.0.0
- connection class: R0 (autonomous)
- trust: 97/100
- quality: 89/100 (new)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/io.github.eftpmc%2Fskeletable
- tools: https://api.protogrid.dev/v1/servers/io.github.eftpmc%2Fskeletable/tools

**An agent can connect right now, no human step.** Remote endpoint, no authentication, reachable on the last probe.

## Connection (mcpServers)

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


## Trust

- hygiene: 100
- liveness: 100
- freshness: 100
- provenance: 90
- drivers: +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.

## Quality 89/100 (new)

### protocol: 75 (weight 25)

- warn `protocol.modern`: newest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
- n/a `protocol.stateless`: only applies to 2026-07-28 servers
- pass `protocol.transport`: streamable HTTP
- n/a `protocol.list_ttl`: only applies to 2026-07-28 servers

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 100 (weight 30)

- pass `tools.descriptions`: every tool has a description
- pass `tools.description_length`: descriptions are concise
- pass `tools.schemas`: every tool has an object input schema
- pass `tools.annotations`: 16 of 16 tools declare readOnlyHint or destructiveHint
- pass `tools.directory_hints`: every tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
- pass `tools.token_cost`: about 4,532 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: n/a (weight 15)

- n/a `stability.changes`, `stability.rug_pull`: tool history recorded for 5 of the 7 days needed

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 16, about 4,532 tokens to load them all
- tool set hash: ea0f09bdfdb77ecad83291f74dd1799f
- tools last changed: 2026-11-02T10:38:03.366Z
- badge: [![protogrid quality](https://protogrid.dev/badge/io.github.eftpmc/skeletable.svg)](https://protogrid.dev/servers/io.github.eftpmc/skeletable)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

- 2026-11-02 `create_table` changed (inputSchema)
- 2026-11-02 `fill_ai_cells` added
  - 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-02 `next_ai_cells` added
  - 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-02 `set_instruction` added
  - 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-02 `fork_table` added
  - 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-02 `save_version` added
  - 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-02 `data_link` added
  - 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-02 `fill_cells` changed (description, inputSchema) **meaning 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: 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-02 `add_rows` changed (description, inputSchema) **meaning 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: 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-02 `add_columns` changed (inputSchema)

Full history: https://api.protogrid.dev/v1/servers/io.github.eftpmc%2Fskeletable/changes

## Remotes

- https://skeletable.com/mcp (streamable-http, auth none, reachable true, uptime30d 1)

## Packages

_none_

## 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`: 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`: 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`: 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 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`: 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`: 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.