# DeckSpace

> Presentations that are web pages, not slide files. Describe your story in chat and DeckSpace builds the whole thing as one live HTML page — in your own house style — and puts it at a shareable URL instead of in a .pptx attachment.

Try it at https://deckspace.org/: browse the templates, drop an HTML deck to preview it, or describe one — then sign up free (Google or email; 75 credits, no card) to build, edit and share.

DeckSpace is where an AI-generated presentation goes to be shared, hosted, commented on, and edited. The generation problem is largely solved by LLMs; DeckSpace is the part after generation — delivery. A deck is a single self-contained HTML page at a link: it opens instantly in any browser with no app or download, its charts compute from real embedded data rather than being typed by the model, and viewers can comment on the exact slide they are discussing. Build on DeckSpace's model with credits, or bring your own Anthropic or OpenAI key — with your own key, nothing is proxied.

## What people use it for

- [Share an AI-generated presentation as a link](https://deckspace.org/share-ai-presentation): turn an HTML deck or AI-built presentation into a URL you send, instead of exporting a file. Opens live in the browser.
- [Host HTML decks and slides](https://deckspace.org/host-html-decks): a home for self-contained HTML presentations — slide decks, scrolling documents, or tabbed dashboards — each at its own shareable, updatable link.
- [Comment on and collaborate on a deck](https://deckspace.org/comment-collaborate): viewers leave comments pinned to the specific slide; the owner edits text in place. No file round-trips.
- [How it compares](https://deckspace.org/vs): DeckSpace versus exporting a .pptx/PDF or dropping HTML on a generic static host.

## Publish straight from your AI (MCP)

DeckSpace ships a Model Context Protocol server, so an assistant that supports MCP can publish a deck directly into the user's workspace and hand back a share link — no download, no upload in between. It can also list the decks in the workspace, read one back, and edit an uploaded or AI-published deck in place by find-and-replace (decks composed with Create-with-AI are read-only over MCP). Official MCP Registry name: `org.deckspace/publish`.

### Install (for an AI agent setting this up)

Endpoint: `https://app.deckspace.org/mcp` — JSON-RPC 2.0 over stateless Streamable HTTP.

**Preferred — OAuth, nothing to copy.** Give the client the bare endpoint URL with no credential. On first use it discovers DeckSpace's OAuth 2.1 authorization server, opens a DeckSpace consent page in the user's browser, and the user clicks **Allow** once — then it is connected. No token to find, paste, or leak. Connecting needs a free DeckSpace account: if the browser isn't signed in, the approval page first offers Sign up free (Google or email) or Sign in, then returns to the consent screen. This works in:

- **Claude Code** (and other coding/CLI agents that manage their own MCP config, e.g. Cursor, Cline) — `claude mcp add --transport http deckspace https://app.deckspace.org/mcp` (no `--header`). An agent like this can act on this document and set itself up; the CLI runs the browser consent step.
- **Claude chat** — Add custom connector, paste `https://app.deckspace.org/mcp`, approve in the browser.
- **ChatGPT** — Settings → Security and login → turn on Developer mode; then on the Plugins page (chatgpt.com/plugins) select the plus button, name the connection and enter the URL. ChatGPT finds the OAuth approval on its own.
- **Gemini** — add the endpoint as a custom MCP server (Gemini Enterprise, or a consumer custom MCP connection). Streamable HTTP only, which is what this endpoint speaks.
- **Grok** — grok.com/connectors → New Connector → Custom, paste the endpoint (paid tiers).

A chat UI (Claude chat, ChatGPT, Gemini, Grok) cannot add a connector to itself — the user does that in its settings; an agent that manages its own tools can do it from this document. Either works with any client that adds a remote (Streamable HTTP) MCP server. The user sees and revokes each connected client under **Settings → Publish → Connected AIs**.

**Fallback — a per-user publish token**, for a client that cannot run the OAuth flow. The agent asks the user for their token from **Settings → Publish**. Two forms:

- **Header form** — send `Authorization: Bearer <token>`:
  `claude mcp add --transport http deckspace https://app.deckspace.org/mcp --header "Authorization: Bearer <token>"`
- **Path form** — put the token in the URL: `https://app.deckspace.org/mcp/<token>`, for a connector dialog that takes only a URL. Here the URL **is** the credential — treat it like a password; the user can rotate it from the same Settings → Publish screen.

The same token also publishes without MCP: `POST https://app.deckspace.org/api/decks` with the header `x-opendeck-token: <token>` and a JSON body `{"title": "…", "html": "<!DOCTYPE html>…"}` (or the file as a multipart `file` field) returns the deck with a live `shareUrl` — unless a Free account is already at its live-deck limit, in which case the deck is saved private and the response carries `liveCapHit`.

Runtime `tools/list` output is the source of truth for schemas.

### Tools

- `publish_deck` — publish a deck from inline HTML. Args: `title` (string), `html` (the complete `<!DOCTYPE html>` document), optional `space` (must match an existing space; omit for "Personal"), optional `create_space: true` (only when the user asked for a new space), optional `sha256` (verified server-side). Returns a share URL. Prefer `create_upload` above ~40 KB or when the deck already exists as a file — every inline byte costs output tokens and one wrong character renders fine while showing wrong numbers.
- `create_upload` — get a short-lived pre-authorized upload URL for a deck that exists as a FILE, without its bytes passing through the model. Args: `title`, optional `space`, optional `create_space`, optional `deck_id` — pass `deck_id` to land the file IN PLACE on an existing uploaded deck: same id and share link, the previous version kept in History (this is how a data deck gets new data; `title` is not needed then). The returned URL is a **web page**: the user opens it in their browser and drops the file in (or a shell can POST to it) — so this works even from a hosted client with no disk, shell or network egress. Use it for files, large decks, or embedded datasets.
- `list_spaces` — list the user's workspace spaces (read-only). Call it before publishing into a named space so a guessed name is not rejected.
- `list_decks` — list the decks in the user's workspace with their ids (read-only), and which are editable here. A deck that was uploaded or MCP-published (a stored HTML document) can be changed with `edit_deck` / `replace_deck`; a deck composed with Create-with-AI is read-only over MCP.
- `read_deck` — return the complete stored HTML of one deck by id (read-only). Use it to view a deck, and to copy an exact string to edit — the stored document is the sanitized form, so match its bytes, not what you originally sent. A large deck costs tokens; if you already know the string to change, call `edit_deck` directly.
- `edit_deck` — change an uploaded/MCP-published deck by find-and-replace. Args: `id`, `old_str` (must be unique unless `replace_all: true`), `new_str`, optional `replace_all`. A version snapshot is kept before every write, and composed decks are refused. Prefer this over regenerating the whole document — it cannot corrupt the rest and costs far fewer tokens.
- `replace_deck` — replace an uploaded/MCP-published deck's whole HTML, keeping its id and share link. Args: `id`, `html`, optional `sha256`. A version snapshot is kept; the new document is re-detected as slides or a scrolling document. For a small change prefer `edit_deck`; for a document that exists as a file, `create_upload` with `deck_id` lands it in place without its bytes passing through the model.

### What DeckSpace does with the deck

DeckSpace takes **either a slide deck or a scrolling document** (including a tabbed dashboard) and detects which one you sent — nothing to declare, no flag to pass. If what you built is a scrolling document — a report, an analysis, a data write-up — publish it as is; do not chop it into slides. The deck is sanitized, hosted in a sandboxed viewer on an isolated origin, and returned as a share link.

## The shape it keeps

A deck takes whatever form the material wants — a slide deck presented to a room, a scrolling document read at a desk, or a tabbed dashboard — decided from the content, not forced into 16:9.

## Also in the app

- **Style from Your Template** — upload the deck your team already uses (HTML, PowerPoint, PDF or an image) and new AI builds reuse its palette, fonts and layouts.
- **Redesign that keeps your words** — ask for a new look and only the design changes; the words stay as they are.
- **Slides or Web page** — a deck is 16:9 slides or one web page (one scroll or tabs), and Restyle switches a built deck from one to the other.
- **Update data** — upload a new CSV or XLSX and every chart recomputes at the same link; the old data stays in History.

## Pages

- [Home](https://deckspace.org/): drop a deck or describe one — sign up free to build and share.
- [Pricing](https://deckspace.org/pricing): sign up free for 75 credits on DeckSpace's model (no key, no card), bring your own key for unlimited unmetered generation, or go Pro ($9/mo, 300 credits) — a $5 top-up buys 100 credits.
- [Template gallery](https://deckspace.org/gallery): ready-made HTML decks in slide and scrolling form, previewable live and usable in one click.
- [Open the app](https://app.deckspace.org)
- [Privacy](https://deckspace.org/privacy)
- [Terms](https://deckspace.org/terms)

## Contact

hello@deckspace.org