← Back to gallery

Deck Hub

How this works

Everything you need to find, present, practise, edit, and share decks, with no local setup required.

Getting access

Deck Hub is Amazon-internal only. Visit presentations.aws.dev and sign in with your Amazon Federate identity (backed by Midway) — there's no separate password or account to create. If you're already logged in to Midway in this browser, sign-in is usually instant.

If login fails or loops back to the sign-in page, first try mwinit -f in a terminal to refresh your Midway session, then reload the page. If it still doesn't work, reach out in #presentations-interest — include the error you saw and roughly when it happened.

Connect your local agent

Install the Deck Hub MCP server with one command:

aim mcp install deckhub-mcp

Once installed, use Quick, Kiro, or another MCP-capable local agent to create decks, edit and move slides, search your library, organise sections, and manage sharing.

Ask naturally, for example: “Create a new technical deck for this customer” or “Move slide 8 to position 3”. Your agent discovers the Deck Hub tools it needs.

Keep the server current

Deck Hub tells your agent when a newer server is available, and refuses versions older than the supported minimum with the exact command to run. When you see either message:

aim mcp update deckhub-mcp

Then restart your agent. Nothing else changes; your sign-in and decks are untouched.

No Toolbox? Connect via GitLab instead

If aim isn't available (or you prefer a config-file setup), the same server runs straight from its GitLab repo via uvx. Add this to your client's MCP config (.mcp.json, ~/.claude.json, Kiro's mcp.json, …):

{
  "mcpServers": {
    "deckhub": {
      "command": "uvx",
      "args": [
        "--refresh",
        "--from",
        "git+ssh://git@ssh.gitlab.aws.dev/ghast/presentations-mcp.git",
        "deckhub-mcp"
      ]
    }
  }
}

--refresh matters: it re-checks GitLab for the latest version on every server start (falling back to the cached copy offline). Without it, uvx pins the first version it ever fetched and you'll silently miss new tools and fixes. Requires uv and a valid Midway session (mwinit).

Deck Hub assistant

Select Ask Deck Hub in the lower-right corner to work with the built-in agent. Responses stream as formatted Markdown, so headings, lists, links, tool activity, and slide previews become readable while the answer is still arriving.

Give the agent useful context

  • Type # followed by a deck name and choose a suggestion. The selected deck is attached to the request as #owner/slug. You can also ask the agent to search for a deck that is not in the current list.
  • Use the paperclip to attach PNG, JPEG, GIF, WebP, PDF, text, or Markdown files, or paste a screenshot or image straight into the message box.
  • Use the microphone in a supported browser to dictate in UK English. The message sends automatically after a short pause, or select the microphone again to stop without sending.

Work across several conversations

Select + for a fresh agent session. Tabs are named automatically and keep their own transcript, draft message, and agent session. Switch tabs to return to earlier work. Drag the panel's left edge to resize it.

Review slides without leaving chat

Click a slide shown by the agent to open it in the large presentation viewer beside the chat. Use the arrow controls to move through the deck, refresh it, or open it in a separate tab. The agent receives the deck and slide currently open with your next message.

When the agent proposes a replacement or new slide, it appears in the Suggestions tray above the message box. Select Preview, then switch between Original and Suggested in the viewer. Select Apply to publish it or Discard to remove it. Nothing is published until you approve it. Suggestions belong to the chat that created them and stay available for 24 hours — reopen the chat to pick them up again; after that they expire and you can ask the agent for a fresh one.

Web requests you did not ask for wait for you

The assistant can search the web and read pages while researching slide content. Pages it found through search, or that you linked in your own message, are read straight away. If it composes an address itself and Deck Hub cannot vouch for it, the assistant pauses and shows an amber Check this web request card with the full address and why it was flagged.

Nothing is fetched until you choose Approve. Deny is the default: sending another message denies the request too, and the assistant carries on without that page. This guards against a shared deck or web page smuggling instructions that would send your content somewhere in a link.

AWS names are checked for you

Every publish checks the AWS offering names in your slides and speaker notes against the approved catalogue. Deprecated names, do-not-use names, missing prefixes and wrong capitalisation come back with the approved replacement in the publish response and as a slide issues pill on the card. Review Studio has a Check AWS names pass for the whole deck, and the assistant will not write a slide using a name the catalogue rejects. Ask it whether a name is right before you use it.

Review Studio — work a full review as a queue

For a whole-deck review, ask the assistant to review this deck (or open Review Studio from the deck menu). Every finding lands against its slide in a persisted queue: the flagged slide shows large with a REVIEW or DROP stamp, the reasoning sits alongside, and you decide each one — A accepts, R keeps as is, C comments, arrows move through the queue.

Accepting a finding doesn't change the deck — ask the assistant to fix it, and after the edit the finding waits for your verification. A suggested drop records the decision only; deleting the slide stays a separate, confirmed action. If a slide changes before you decide, its finding is marked stale rather than applied to the wrong content. Your queue survives edits, reorders and reloads, and updates live while agents add findings.

Presenting & practice

Inside a deck, use the following controls:

Adapt the audience screen to the room

Presenter view includes Light, Dark, and Contrast controls for the live audience deck. The change is immediate, does not reload the deck or reset media and effects, and stays synchronised across a shared presenter session. Press d in presenter view to cycle through the three modes quickly.

Speaker notes persist to the cloud for the deck's owner and anyone with editor access — edits in presenter view save automatically via the deck's own notes API. If you only have viewer access, notes still work but stay in your browser's local storage only (they won't sync anywhere or be visible to anyone else).

Practise a presentation

Open a hosted deck in Presenter view, select Practice, and allow microphone access. Deck Hub follows slide changes while it transcribes your delivery. Use Mute when needed and Stop to finish.

The report covers clarity, pace, energy, filler words, structure, and professionalism, plus duration, word count, words per minute, strengths, improvements, grammar, and progress against the previous run.

Optional slides — detours for deep dives

A deck can carry slides that sit outside the normal flow: pressing next or previous skips straight over them. They are reached through a marked element on another slide — a "Deep dive" pill, a stat, an image — and once you are on the detour, next or previous returns you to exactly the slide you came from. Detours can nest.

Use them for the material you only bring out if the room asks. In presenter view the filmstrip shows detours as a dashed branch hanging under the slide that links to them, like a branch in a git graph — click a branch thumbnail to take the detour directly. Optional slides still appear in the PDF export.

Present safely while others edit

A publish by another user does not replace the deck in the middle of your presentation. Presenter view shows This deck was updated by someone else; select Reload when you are ready to adopt the new version. Note changes sync live unless you have an unsaved local edit, in which case Deck Hub asks before replacing it.

Shared presenting

Two or more presenters can control one audience screen. One person shares the audience view in the meeting; every presenter opens their own presenter console and can move the shared presentation without changing screen share.

Start a session

Open Presenter view on your deck and select Share control. Your paired audience tab becomes the shared screen automatically. The session rail shows a copyable join link, a six-character code you can read out across the room, and everyone connected.

Invite co-presenters

Three ways in, all requiring viewer access to the deck:

  • By alias — type an alias in the session rail and press Enter. They get a styled email with a personal join link and skip the waiting room entirely.
  • By link — anyone opening the copied link waits until you admit them from the rail.
  • By code — same as the link, for when reading six characters aloud is easier. Codes expire after 15 minutes.

During the session

Every admitted presenter gets the full console — next-slide preview, filmstrip, notes, and a shared elapsed timer, so everyone agrees how far into the talk you are. Next, Previous, and the filmstrip all drive the shared screen; after a remote move the rail briefly shows Moved by <alias>. Staged reveals and carousels stay perfectly in sync.

The host can invite more people or remove someone at any point from the rail. Removal takes effect immediately. The deck itself is snapshotted for the session — a publish mid-talk never changes what the audience sees.

If something goes wrong

Walking to the machine driving the screen and pressing an arrow key always works — the session follows along. If the audience screen closes, the session pauses (rather than guessing a new screen) until you attach one. If your connection drops, reconnect and you resume where the session actually is.

Managing decks

Open a card's menu for deck-level actions. The options shown depend on your role.

ActionHow to use it
DownloadChoose source zip, standalone zip with theme assets, single self-contained HTML, or PDF.
PDF exportSelect PDF. Rendering runs as a background job and the progress pill remains visible until the browser downloads the completed file.
HistoryPreview earlier versions, see who published each one, and restore a version if you have editor access.
Upload zipOwners and editors can replace a deck from a zip. Large files upload directly to storage and report progress.
Theme and tagsChange the deck theme or add searchable tags without rebuilding the deck.
ChoreographyAssign presenters to slide ranges. Presenter view then identifies the current speaker and counts down to the next handover.
Runtime updateWhen a newer deck runtime is released, cards you own offer an update, and Update all brings every deck you own across in one go. Each deck is validated first: one that would break is reported with the missing file, never published broken.

Create a section with + New section. Owners and editors can drag decks between sections. You can also rename or delete sections, or ask the Deck Hub agent to move a deck when working through chat or MCP.

Authoring via MCP

For the standard Amazon setup, run aim mcp install deckhub-mcp and use Deck Hub from Quick, Kiro, or another local agent. The manual connection options below are available when you need a file-aware local checkout or a remote MCP configuration.

Option A

Local MCP server — runs on your machine via uvx. Adds file-aware tools that operate on a whole deck folder at once (push_deck, pull_deck, push_file, deck_status), plus a remote_tool passthrough to everything the remote server offers. Recommended if you're authoring from a local checkout of a deck.

Option B

Remote MCP server — nothing to install. Works from any MCP-capable chat client, including ones with no filesystem access. You author by passing HTML/markdown directly as tool arguments rather than syncing files.

Option A — Local MCP server recommended for deck authoring from your machine

1Prerequisites

You need mwinit (Midway — already on every Amazon dev machine) and uv installed (pip install uv, or see the uv install docs). Everything else — the MCP server itself — is fetched on demand by uvx, no separate install step.

2Add the MCP server

The server config runs the package straight from its GitLab repo via uvx — client-agnostic, works with Claude Code, Kiro, or any other MCP-capable client:

{
  "mcpServers": {
    "deckhub": {
      "command": "uvx",
      "args": [
        "--refresh",
        "--from",
        "git+ssh://git@ssh.gitlab.aws.dev/ghast/presentations-mcp.git",
        "deckhub-mcp"
      ]
    }
  }
}

Drop that into a project-level .mcp.json (shared with a repo/team), or into your user-scope config (~/.claude.json for Claude Code — check your client's docs for the equivalent user-scope file) to make it available everywhere. Keep the --refresh flag — it's what keeps you on the latest version (see the update note below).

Prefer a one-liner? Claude Code's CLI does the same thing:

claude mcp add deckhub -- uvx --refresh --from git+ssh://git@ssh.gitlab.aws.dev/ghast/presentations-mcp.git deckhub-mcp

3Authenticate

The first tool call opens a browser window for Federate sign-in (via Midway) — same identity you use to sign in to the gallery. You only need to do this once per machine until the token expires. Make sure you've run mwinit recently so that sign-in doesn't stall.

4Sync a deck folder

push_deck and pull_deck sync an entire deck folder in one call, hash-diffing so only changed files actually transfer — no need to call put_deck_html/upload_asset file-by-file. push_file is the single-file equivalent when you only touched one thing; deck_status shows what's changed locally vs. what's published without pushing anything.

Everything else — sharing, groups, search, versions — goes through remote_tool, a passthrough to the full remote tool set described in Option B below (same find_tool / describe_tool / execute_tool pattern, just reached via remote_tool("execute_tool", ...) instead of calling it directly).

Updates: with --refresh in your config (as above), uvx re-checks GitLab for the latest version on every server start — no manual upgrade step (offline it falls back to the cached copy). Without the flag, uvx pins the first version it ever fetched, forever — if you installed before this flag was documented, add it to your config, or force a one-off update with uv cache clean presentations-mcp and restart your client. The whoami tool reports the server build it's talking to. Full docs and troubleshooting live in the repo itself: gitlab.aws.dev/ghast/presentations-mcp.


Option B — Remote MCP server no install; chat clients / no filesystem

1Add the MCP server

The server config is one small JSON block — client-agnostic, works with Claude Code, Kiro, or any other MCP-capable client:

{
  "mcpServers": {
    "deckhub": {
      "type": "http",
      "url": "https://presentations.aws.dev/mcp"
    }
  }
}

Drop that into a project-level .mcp.json (shared with a repo/team), or into your user-scope config (~/.claude.json for Claude Code — check your client's docs for the equivalent user-scope file) to make it available everywhere.

Prefer a one-liner? Claude Code's CLI does the same thing: claude mcp add --transport http deckhub https://presentations.aws.dev/mcp. Either approach produces the identical config — use whichever fits your workflow.

2Authenticate

Inside your agent session, run /mcp and choose to authenticate. A browser window opens, redirects through Midway/Federate, and hands back an access token to your agent — the same identity you use to sign in to the gallery. You only need to do this once per machine until the token expires.

3Use the three meta-tools

Deck Hub exposes exactly three MCP tools — find_tool, describe_tool, and execute_tool — which front every real capability (create decks, publish HTML, upload assets, manage sharing, search, manage groups). Your agent typically calls these for you when you ask in plain English, but the pattern is:

  • find_tool("share a deck") — search for the operation you want by description; returns matching tool names.
  • describe_tool("set_sharing") — get the exact input schema (required/optional fields) for a tool you found.
  • execute_tool("set_sharing", {...}) — actually run it.

No local filesystem here, so there's no push_deck/push_file to sync files from — author with put_deck_html (full deck) or put_slide (one slide at a time) instead, passing HTML directly as an argument. See get_guide("sync") for the full comparison between file-based and inline authoring.

Worked example — create a deck, publish its HTML, then share it with a colleague (identical whether you're on the remote server directly or reaching it via remote_tool from Option A):

execute_tool("create_deck", {
  "slug": "q3-roadmap",
  "title": "Q3 Roadmap",
  "section": "Talks"
})
→ {owner: "yourAlias", slug: "q3-roadmap", s3Prefix: "decks/yourAlias/q3-roadmap/"}

execute_tool("put_deck_html", {
  "owner": "yourAlias",
  "slug": "q3-roadmap",
  "html": "<!DOCTYPE html>..."   // full deck HTML, built from the aws-deck template
})
→ {ok: true, slideCount: 12}

execute_tool("set_sharing", {
  "owner": "yourAlias",
  "slug": "q3-roadmap",
  "principal_type": "user",
  "principal_id": "colleagueAlias",
  "role": "editor"
})
→ {ok: true}

Ask your agent to "build me an AWS-themed deck about X and publish it to Deck Hub" and it will typically drive all three steps itself, including writing the slide HTML using the AWS Deck template. If you're on the local server (Option A) and already have the deck as a folder on disk, push_deck replaces the middle put_deck_html step with a single hash-diffed sync of the whole folder — faster, and it won't re-upload files that haven't changed.

Slide vocabulary quick reference

Every slide is a <section class="slide ...">. This is the condensed version of the full AWS Deck authoring guide — your agent has the complete version via the deckhub://guide/slide-vocabulary MCP resource.

Slide typeClasses
Titleslide title bg-lilac — logo + h1 + .subtitle + .presenter
Agendaslide.kicker + h2 + <ol class="agenda">
Section break (light)slide section bg-spectrum (or bg-mint, bg-sunset)
Section break (dark)slide section dark bg-dark-blue (or bg-dark-vivid, bg-dark-aurora)
Contentslide.kicker + h2 + bullets, .cols.two/.three/.four of .cards, or a table
Big statsslide dark bg-dark-vivid.cols.three of .stat (.num + .label)
Quoteslide quote bg-mint<blockquote> + <cite>
Codeslide — h2 + <pre><code> with syntax-highlight spans
Thank youslide thanks bg-warm (or bg-green, bg-lilac)

Helpers: .rise on direct children = staggered entrance; accent colours .accent-blue/-purple/-green/-pink/-orange; a <div class="speaker-notes"> inside any slide feeds the presenter-view notes panel.

EffectRecipe
Staged reveal<div data-reveal> wrapping .reveal-step children — each Next press reveals one more; Previous hides the last one; falls through to normal slide nav once all are shown.
Lens / magnifier<div class="lens-scene" data-lens> of .lens-tiles plus one .lens-glass — a circular glass drifts and magnifies whatever's underneath. Purely ambient, no keyboard interaction.
Full-bleed imageslide full-bleed [dark] [scrim-light] [scrim-bottom] with style="background-image:url(...)" and an .overlay-text block for the heading. No JS required.

These ship in assets/css/effects.css + assets/js/effects.js (include both after deck.js) — full markup recipes are in the AWS Deck authoring guide.

Design guidance

Slide vocabulary tells you which classes to use. This is the judgement layer above it — the difference between a technically correct slide and one that actually lands with an audience.

Type floors

Set a real minimum with clamp(min, preferred, max), never a bare vw/vh value with no floor. Keep supporting text at or above 20px at the 1920×1080 design size — a size that looks slightly large on a monitor is usually just readable from the back of a room. Move detail into speaker notes rather than shrinking text to fit it on the slide.

One message per slide

Prefer fewer, larger elements to many small cards. If two ideas remain on one slide, split it into two.

Headline as conclusion

Make the headline state what the evidence proves, not merely the topic — "The app token authenticates the caller; the user token delegates Graph access", not "Token architecture". A reader should get the point from the headline alone, before looking at the supporting visual.

Which pattern, when
You needReach for
A short, unordered set of pointsStatic .cols of .cards — no interaction needed
Content that matters in full but can't be read all at once, presenter-pacedStaged reveal (data-reveal) — see the Slide vocabulary chapter above
A dense, roughly-equal-weight inventory that should feel ambient, not click-drivenLens / magnifier (data-lens)
A narrative photo momentFull-bleed image + overlay text — no JS required
A one-off diagram (flow, lanes, stack, code window)Deck-local CSS scoped to one slide/component class — no platform primitive exists for these; write it as illustrative CSS following the shared theme tokens

Contrast rules: squid ink and paper carry the main contrast; purple is the primary accent on light slides, blue on dark (both auto-switch via the dark class); green means persisted/successful/complete; don't assign colour meaning at random. Spacing rhythm: vh for vertical spacing tied to the slide, vw for horizontal, explicit grid tracks for diagrams rather than auto-fill.

This is the condensed version. Your agent has the complete authoring guide — type floor rationale, every built-in effect's markup and failure modes, presenter-view internals, a full authoring checklist — via get_guide("design") in MCP.

Sharing model

Every deck is private by default. Sharing is explicit and layered: grant access to an individual person, a group, or everyone. Access can come from the deck itself or be inherited from its section.

Owner

Full control — edit, delete, and manage sharing for the deck.

Editor

Can publish new slide content and edit speaker notes, but can't change sharing or delete the deck.

Viewer

Can open, present, and search the deck; notes stay local to their browser only.

Share one deck

Open the deck's menu and select Share, or select its shared-status rail. Add a user alias, group name, or everyone grant, choose viewer or editor, and remove grants from the same modal.

Share a whole section

Select Share beside the section heading. The grant applies to every deck currently in that section and to decks moved there later. Recipients see a tinted section background instead of a repeated sharing rail on each card. Renaming the section keeps its grants; deleting a shared section warns that those grants will be removed.

Your Public section

Everyone has a Public section. Move a deck into it and any signed-in colleague can view it at /p/<your alias>/public, with no grants to manage. It stays hidden on your own gallery while it is empty; turn on Show Public section in the avatar menu to see it early. Other people's public decks never appear in your gallery; you reach them through their public page or by asking your agent.

Corporate groups come from BRASS. Choose the group type and exact identifier in the sharing modal. For Teams, use the immutable amzn1.abacus.team.* ID. Manage membership in the system that owns the group; Deck Hub and its MCP server do not create groups or expose their member lists.

Sharing with a specific user or group sends an in-app notification and can send an email containing a direct link. Use Email notifications in your avatar menu to turn your own sharing emails on or off; the bell inbox is always on. Everyone grants never send a broadcast. A failed notification does not undo the access grant.

Usage analytics

The Analytics link appears only for the configured analytics owner. It combines gallery, presentation, agent, MCP, and service telemetry without exposing the dashboard to other users.

Use the period controls to compare recent activity, then review active users, time on site, return usage, value signals, presentation modes, slide reach, top decks, client and MCP usage, feature adoption, hourly activity, deck size and slide count, and API/MCP health. Filter the inventory table by deck, owner, section, or slug, and select Refresh for the latest data.

Analytics improve as newer clients emit engagement events. The data-quality panel explains where older activity has incomplete session, duration, or completion information.

Bugs & feature requests

Deck Hub has a shared backlog at /backlog, also reachable from Backlog in the header. Every bug and feature request anyone logs is visible to everyone signed in, with votes, comments and a status that moves from new to triaged, planned, in progress and resolved.

Log one

Tell the assistant, or your own agent, what is broken or missing. It gathers the details (steps, expected and actual behaviour, the exact error text; or the problem, the outcome you want and why it matters), shows you exactly what will be stored, and nothing is submitted until you confirm. Before logging, it checks whether the same thing already exists and offers a vote instead.

Follow it

Open a report to see its comments and triage history. Vote for what matters to you (one vote per person), comment with more detail, and edit your own report's wording. Show closed reveals resolved, closed and duplicate reports.

Support

Bugs and feature requests belong in the backlog, where everyone can see and vote on them. For questions, or if login isn't working, a shared deck isn't showing up, or something in the gallery looks broken right now, post in #presentations-interest.