When you want an AI agent to build a deck from a prompt, the format you target decides everything. LLMs emit text, so the frameworks that win are the ones whose source is plain text or markup the model can write directly: Markdown, HTML, MDX. The agent writes a file, you render it, and the deck drops into git like any other artifact. It diffs, it reviews, it rebuilds in CI, and when a slide is wrong you fix the source instead of regenerating a binary.
The contrast is the AI-native generators (Gamma and friends): prompt in, finished deck out, no source you control. They make a polished first draft fast, but the deck lives inside their editor and the pipeline ends at their export button. For a controllable agent workflow, that is the weaker end. This note surveys both families. The focus is the code and markup frameworks an agent writes source for.
Code & markup frameworks
The agent-friendly family. Three frameworks lead, each with its own deep-dive note. The rest are a short catalog.
The three to know
reveal.js - the most flexible, and the only one that renders a finished deck from a single CDN-linked HTML file with zero tooling, which makes it the safest default for agent-generated slides. The agent emits one .html file with three <script>/<link> tags pointed at a CDN, and it opens by double-clicking. Slides are <section> blocks or Markdown. See the full note: reveal.js
Slidev - the developer's deck: one Markdown file plus an embedded-Vue escape hatch, built on Vue 3 + Vite, with the best code tooling of the three (Shiki highlighting, live Monaco blocks). The trade is that it needs Node and a build step to render. See the full note: Slidev
Marp - plain-Markdown and content-first: the source is near-CommonMark, which makes it the most LLM-friendly to generate, easy to render headless in CI, and it has native .pptx export. The ceiling is lower on interactivity (no fragments, no rich transitions). See the full note: Marp
Comparison
| Framework | Source format | Output | Build / tooling | Agent-friendliness |
|---|---|---|---|---|
| reveal.js | HTML sections or Markdown | HTML (PDF via print) | None: one CDN-linked file | High: emit one self-contained .html, zero install |
| Slidev | Markdown + embedded Vue | SPA, PDF, PPTX, PNG | Node + Vite build | High source, but rendering needs a Node project |
| Marp | Plain Markdown + directives | HTML, PDF, PPTX, PNG | Light CLI (npx) |
Highest: near-CommonMark, headless in CI |
| reveal-md | Markdown (reveal.js) | reveal.js deck | Node CLI | Good, but the wrapper is maintenance-only now |
| remark.js | Markdown in one HTML page | Single HTML file | None (CDN) | Good idea, but effectively unmaintained since 2020 |
| impress.js | HTML + data-attributes | Zoom/3D HTML canvas | None (CDN) | Workable, but positioning is fiddly hand-tuning |
| Spectacle | React / JSX | React app | Node build | Moderate: JSX is more surface to get wrong than MD |
| mdx-deck | MDX (Markdown + React) | React app | Node build | Abandoned: do not start here |
| WebSlides | HTML | HTML | None | Dormant but stable; class-heavy markup |
| shower | HTML / CSS / JS | HTML (+ PDF) | None | Fine for static HTML decks |
| eagle.js | Vue 2 components | Vue app | Node build | Frozen on Vue 2 (EOL); use Slidev instead |
| Big | Single HTML file | HTML | None | Minimal by design; one body, one file |
| Patat | Markdown (Pandoc) | Terminal (ANSI) | Haskell binary | Niche: presenting in a terminal |
The three at the top are the live, maintained choices. Below them:
- reveal-md wraps reveal.js so a plain
.mdfile renders with live reload. Convenient, but the project is in maintenance-only mode and points users at Slidev. - remark.js (the gnab/remark slideshow tool, not the markdown-AST processor) is the original single-HTML Markdown deck. Clean concept, but the last release was 2020. Not a confusion to make: the unrelated
remarkAST library shares the name. - impress.js does Prezi-style zoom and 3D transforms on an infinite canvas. Striking, but every slide is hand-positioned with data-attributes, which is exactly the fiddly work an agent is bad at.
- Spectacle (React, maintained by Nearform) writes slides as JSX with live-code demos. Reasonable if the project is already React, but JSX gives the model more to get wrong than Markdown.
- mdx-deck pioneered MDX decks (Markdown plus React components). It is unmaintained now (last commit years ago, 140+ open issues). Do not start a new deck here.
- WebSlides and shower are HTML engines for clean, story-driven slides. Both render from static files; WebSlides is dormant-but-stable, shower is still maintained.
- eagle.js is a Vue slideshow framework, but it is frozen on Vue 2 (now end-of-life) and its own docs send you to Slidev.
- Big by Tom MacWright is a single HTML file: write text in the
<body>, present. Deliberately tiny, stable, no styling to speak of. The fastest possible thing an agent can emit when the content is one line per slide. - Patat renders Markdown presentations in the terminal (Haskell, Pandoc-backed, actively maintained). Niche, but the right tool when the deck is for a terminal session.
Generate real PowerPoint (.pptx)
Sometimes the deliverable has to be an editable PowerPoint file, not an HTML deck. People want to open it, restyle it, and drop it into a corporate template. Two libraries let an agent emit real .pptx directly, building shapes, text, tables, and charts in code rather than rendering through a browser.
- PptxGenJS (JavaScript / TypeScript) generates
.pptxin Node or the browser. Object-model API: add slides, place text boxes, tables, charts, images by coordinate. Active, well documented. - python-pptx (Python) is the de facto standard for creating and editing
.pptxwithout PowerPoint installed. The same object model in Python: slide layouts, placeholders, shapes, charts. It is the natural fit in my stack (Python first). Maintenance has been quiet lately and community forks exist, but it remains the standard and works fine.
The trade-off vs Marp's --pptx: the libraries give you full programmatic control (exact positions, data-driven charts, hundreds of generated slides), at the cost of writing layout code. Marp gives you Markdown and a quick PPTX with less control. Reach for the libraries when the .pptx is the product and it has to be precise or generated at volume.
AI-native generators
The other family: SaaS tools where you type a prompt or paste a doc and get a finished, designed deck. No source code, no framework. The model picks the layout, the images, and the theme for you.
The main ones, all live as of mid-2026:
- Gamma - the category leader. Prompt, outline, or upload in; a designed deck out, with export to PDF, PPTX, and Google Slides.
- Beautiful.ai - smart templates that auto-adjust layout as you add content. Team-oriented.
- Genially - interactive presentations, infographics, and quizzes with AI built in.
- Presentations.ai - branded decks from text, docs, or a URL, with editable PowerPoint export.
- Plus AI - runs as a native add-on inside Google Slides and PowerPoint, so the output stays in the tool people already use. The most pipeline-friendly of the SaaS set for that reason.
- Decktopus, MagicSlides, SlidesGPT - prompt-to-deck builders, MagicSlides and SlidesGPT lean on Google Slides / PowerPoint output.
- Canva - Magic Design for Presentations generates a full deck from a text prompt inside Canva's design engine.
Worth knowing: Tome was a prominent AI deck tool, but it shut down its presentation product in 2025 and pivoted away. Do not reach for it.
Why they are weaker for an agentic pipeline:
- No source you own. The deck lives in their editor. You get an export, not a file your agent authored and can re-run.
- Black-box layout. You cannot diff a generated deck, review it as a change, or re-prompt against the exact markup. The model inside their product chose the layout, not yours.
- The pipeline ends at export. Fine for a one-off draft, awkward when the deck is one step in a longer automated flow that has to regenerate on new data.
When do they make sense? When a human wants a fast, good-looking first draft and is going to finish it by hand in that same tool. That is a real use case, just not a controllable agent pipeline.
What I'd reach for
For agent workflows, by deliverable:
- Markdown into CI, and a PPTX at the end -> Marp. Near-CommonMark source the model writes cleanly, headless rendering, native
.pptx. The default when speed and reliability beat visual polish. - Zero-build HTML control -> reveal.js. One self-contained
.htmlfile from a CDN, opens immediately, full web platform available. The safest target when there is no build environment. - A Node project already, and dev polish is fine -> Slidev. Best code tooling and the slickest result, once the build step is acceptable.
- The output must be an editable .pptx -> python-pptx or PptxGenJS. When people need to open and restyle a real PowerPoint, or the decks are data-driven and generated at volume. python-pptx in my Python stack, PptxGenJS in a JS one.
- A fast human first draft, finished by hand -> an AI-native generator (Gamma). Not an automated pipeline, but the quickest route to a polished draft a person will edit.
Short version: text-source frameworks for anything an agent runs end to end; the .pptx libraries when editable Office is the product; the SaaS generators only when a human is driving and editing.
What I'm building: NicDeck
For my own Kaltura sales decks I took the survey one step further and started building a system on top of reveal.js, called NicDeck. The reasoning is the table above: reveal.js is the safest target for agent-generated slides, so rather than adopt a finished tool I wrap it in a thin, opinionated layer and let Claude generate the decks.
The shape:
- Every deck is a single movable
.htmlfile. The engine and my theme live centrally and are referenced, not copied, so every deck always renders the latest design. Graphics and video stay in a central media library, linked by absolute URL. - A small local server (caddy on
127.0.0.1) makes cross-directory assets and video work, whichfile://cannot. - Fixed 1920x1080, five slide templates, fragment animations, vertical nav plus the overview grid, and export to PDF and PPTX.
- Generation is agentic: a master orchestrator with subagents pulls the relevant master-deck slides, product knowledge, and client knowledge, applies the brand rules (Kaltura logo on every slide, client logo on the title), then loops the draft past a Council of expert personas, up to 10 rounds, until each scores it at least 9/10, with a final visual-QA pass.
Full writeup: NicDeck
The individual framework notes
The three deep-dives, each its own note:
- reveal.js - most flexible, zero-build single HTML file, safest default for agent output: reveal.js
- Slidev - developer's deck, one Markdown file plus a Vue escape hatch, best code tooling, needs Node: Slidev
- Marp - plain-Markdown and content-first, most LLM-friendly, headless in CI, native
.pptx: Marp