Agent Skills for Presentations: How to Give Your AI the Power to Build PowerPoint Files

The Agent Revolution Is Already Here

In January 2026, Boris Cherny — the creator of Claude Code — posted his daily workflow and racked up 4.4 million views. He runs five Claude instances in parallel: one on a feature branch, one running tests, one cleaning up architecture. Fleet commander, not typist. As one developer put it after replicating the setup: “It feels more like Starcraft than coding.”

The most productive people with AI aren’t using it as a chatbot. They’re assembling agents into workflows, giving each one specific skills, and letting them run — and platforms like Vercel, Anthropic, and OpenClaw have spent the last year building an open ecosystem to make that pattern available to everyone.

What Are Agent Skills, and Why Do They Matter Now?

An agent skill is a packaged set of instructions, scripts, and context that you install into an AI agent — giving it a new, specialized capability it didn’t have before.

Think of it like npm, but for agent knowledge and behaviour rather than code libraries. In fact, Vercel’s InfoQ write-up described the moment explicitly: “This is npm for AI agents. The key insight: Skills prioritize composability over protocol complexity.”

The Boris Cherny post wasn’t the only viral moment in the agent space in early 2026. Around the same time, Austrian developer Peter Steinberger published OpenClaw — an open-source autonomous AI agent that runs locally on your machine and connects to your messaging apps: WhatsApp, Telegram, Slack, iMessage, Discord. You message it like a person, and it executes tasks on your behalf. The project hit 247,000 GitHub stars in under 60 days, making it one of the fastest-growing open-source repositories ever recorded.

What made OpenClaw explode wasn’t the agent itself — it was the skills system. OpenClaw’s ClawHub skill registry now hosts over 13,700 community-built skills, from GitHub automation and Slack management to trading bots and — yes — presentation generation. Every skill is a SKILL.md file with instructions and scripts the agent can call when needed. Install a skill and your OpenClaw agent gains a new capability, immediately, without any code changes.

This is the same pattern Vercel formalised in January 2026 when they launched skills.sh — an open directory and leaderboard for skill packages across all agents — alongside a CLI that lets you install skills with a single command:

npx skills add SlideSpeak/skills

That one command installs a skill from GitHub directly into whichever agents you’re using. Skills work across the full agent ecosystem: Claude Code, Cursor, OpenClaw, Codex, GitHub Copilot, Goose, Windsurf, Kiro, Trae, and more. You install once; every agent in your environment gets the capability.

The idea behind skills is simple but powerful: AI models know general programming languages and frameworks, but they don’t know your folder structure, your design system, your deployment rules, or what your data looks like. Skills let you close that gap without re-explaining it from scratch every session. You install the skill, and the agent loads the relevant context whenever it’s needed.

As one commenter put it in Vercel’s InfoQ write-up: “This is npm for AI agents. The key insight: Skills prioritize composability over protocol complexity.”

Great starting points from the skills ecosystem:

Vercel Agent Skills — Deploy to Vercel, review React code, enforce Next.js patterns
Browser Use — Give agents the ability to navigate real websites
SlideSpeak — Give agents the ability to generate and edit PowerPoint files
Browse everything else at skills.sh and clawhub.ai

The Output Gap: Why Presentation Skills Are Especially Valuable

Most agent workflows are good at reasoning, retrieval, and writing. But they almost always stop at text. The final output — the thing a human actually needs to use — still requires manual work to produce.

Ask an agent to “put this in a deck” and it either apologises, gives you bullet points to copy-paste, or generates markdown that someone still has to turn into slides. That’s fine for a one-off, but it completely breaks down in any automated pipeline. A scheduled weekly report, a personalised sales deck generated per-prospect, an executive summary from a meeting — all of these require someone to do the last step by hand.

A presentation skill closes that gap. It gives your agent the ability to produce a finished, editable .pptx file as the final output of a workflow — with no human formatting step in the middle.

Installing the SlideSpeak Agent Skill

The SlideSpeak Agent Skill is available on GitHub, on LobeHub / ClawHub, and via skills.sh. It works across Claude Code, OpenClaw, Cursor, Codex, and any other agent that supports the skills standard.

Option A: Install via the skills CLI (Claude Code, Cursor, Codex, Goose, Windsurf…)

npx skills add SlideSpeak/skills

This installs the skill for all agents in your environment. To target a specific agent:

# Claude Code only
npx skills add SlideSpeak/skills -a claude-code

# Cursor only
npx skills add SlideSpeak/skills -a cursor

# Multiple agents at once
npx skills add SlideSpeak/skills -a claude-code -a cursor -a opencode

Option B: Install in OpenClaw via ClawHub

If you’re using OpenClaw — the self-hosted agent that runs through WhatsApp, Telegram, or Slack — the SlideSpeak skill is published on the ClawHub registry at clawhub.ai and LobeHub.

Install it using the ClawHub CLI:

claw install slidespeak

Or install manually by cloning the repo into your OpenClaw skills directory:

git clone https://github.com/SlideSpeak/skills.git ~/clawd/skills/slidespeak

Once installed, restart your OpenClaw session. Then message your agent on WhatsApp or Telegram:

“Create a 10-slide presentation about our Q3 sales results in a professional tone.”

OpenClaw will invoke the SlideSpeak skill, generate the deck, and return a download link — all through a chat message.

Option C: Install manually (any environment)

Clone the repo and point your agent at the skill directory:

git clone https://github.com/SlideSpeak/skills.git

The skill lives at skills/slidespeak/ and contains the SKILL.md instruction file and the scripts/slidespeak.mjs helper that handles API calls and polling.

Set your API key

Get your key at slidespeak.co/slidespeak-api and set it as an environment variable:

export SLIDESPEAK_API_KEY=your-api-key-here

Two Generation Modes: Prompt-Based and Slide-by-Slide

Once the skill is installed, your agent can generate PowerPoint files in two ways.

Prompt-based generation is the faster path for open-ended content. Give the agent a topic, document, or conversation summary and SlideSpeak structures the deck automatically:

node scripts/slidespeak.mjs generate \
  --topic "Q1 Marketing Strategy Review" \
  --document ./meeting-notes.txt \
  --length 10 \
  --tone professional

Slide-by-slide generation is the mode built specifically for agents that already have structured data — CRM exports, analytics results, database queries. Instead of asking SlideSpeak’s AI to guess the structure, the agent defines every slide explicitly: layout, content, and data. That’s where things get genuinely powerful.

Slide-by-Slide Generation: The Mode Built for Agents

When an agent has already fetched data from a CRM, an analytics platform, or a database, it knows exactly what each slide should contain. The slide-by-slide API lets the agent act on that knowledge directly.

You pass an array of slide objects, each specifying:

title — the slide heading
layout — the visual layout type (see below)
item_amount — the number of content items the layout should render
content — the text content for that slide
images (optional) — stock photo keywords, a URL, or an AI generation prompt
chart (optional) — structured chart data for CHART layout slides
table (optional) — row/column data for TABLE layout slides

The result is a fully designed .pptx where the agent controlled every slide — layout, data, and content — without any AI improvisation on the structure.

Available Layouts

SlideSpeak provides 16 layout types, each designed for a specific kind of content:

Layout	Items	Best for
`ITEMS`	1–6	General bullet-point content
`STEPS`	3–5	Sequential processes
`SUMMARY`	1–5	Closing key-takeaways slide
`COMPARISON`	Exactly 2	Side-by-side contrast (e.g. win vs. loss reasons)
`BIG_NUMBER`	1–5	KPIs, metrics, key stats
`MILESTONE`	3–5	Chronological key dates
`TIMELINE`	3–5	Progress over time
`FUNNEL`	3–5	Pipeline stages, conversion steps
`CYCLE`	3–5	Recurring or looping processes
`PYRAMID`	1–5	Hierarchical levels
`SWOT`	Exactly 4	Strengths / Weaknesses / Opportunities / Threats
`PESTEL`	Exactly 6	Political / Economic / Social / Tech / Env / Legal
`QUOTE`	1	A memorable quote
`CHART`	0	Bar, line, pie charts with structured data
`TABLE`	0	Row/column data tables
`THANKS`	0	Closing thank-you slide

The mapping between layout and data type is exactly what makes this mode powerful for agents: a CRM export has deal values → BIG_NUMBER. It has pipeline stages → FUNNEL. It has a top-deals list → TABLE. The agent knows this. Slide-by-slide lets it say so directly.

Real-World Example: CRM Sales Deck, Slide by Slide

Here’s a complete end-to-end example of an agent that pulls sales data from a CRM and turns it into a polished weekly sales deck — every slide defined explicitly, no AI guesswork on structure.

The Data the Agent Has

const crmData = {
  weekEnding: "March 14, 2026",
  kpis: {
    revenue: "$412,000",
    newDeals: 18,
    avgDealSize: "$22,900",
    winRate: "34%",
  },
  pipeline: [
    { stage: "Leads", count: 184 },
    { stage: "Qualified", count: 67 },
    { stage: "Demo", count: 29 },
    { stage: "Proposal", count: 14 },
    { stage: "Closed Won", count: 6 },
  ],
  topDeals: [
    ["Company", "Value", "Stage", "Owner"],
    ["Acme Corp", "$95,000", "Proposal", "Sarah K."],
    ["Globex Inc", "$74,000", "Demo", "Marcus T."],
    ["Initech", "$61,500", "Proposal", "Lisa M."],
    ["Umbrella Co", "$48,000", "Qualified", "James R."],
  ],
  winLoss: {
    winReasons: "Strong ROI case, fast onboarding, responsive support",
    lossReasons: "Price sensitivity, competitor integrations, long legal review",
  },
  quarterMilestones: "Jan: Q4 target set at $1.6M. Feb: $380K closed, 24% to goal. Mar: $412K week, on track for $1.52M full quarter.",
};

The Slide-by-Slide API Call

The agent maps that data directly onto slides, choosing the right layout for each data type:

const response = await fetch(
  "https://api.slidespeak.co/api/v1/presentation/generate/slide-by-slide",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-Key": process.env.SLIDESPEAK_API_KEY,
    },
    body: JSON.stringify({
      template: "DEFAULT",
      language: "ENGLISH",
      fetch_images: false,
      add_speaker_notes: true,
      slides: [

        // Slide 1 — KPIs as big numbers, immediately scannable
        {
          title: `Weekly Sales Report — w/e ${crmData.weekEnding}`,
          layout: "BIG_NUMBER",
          item_amount: 4,
          content: `Revenue Closed ${crmData.kpis.revenue}. New Deals ${crmData.kpis.newDeals}. Average Deal Size ${crmData.kpis.avgDealSize}. Win Rate ${crmData.kpis.winRate}.`,
        },

        // Slide 2 — Pipeline stages as a funnel
        {
          title: "Sales Pipeline",
          layout: "FUNNEL",
          item_amount: 5,
          content: crmData.pipeline
            .map((s) => `${s.stage}: ${s.count} deals`)
            .join(". "),
        },

        // Slide 3 — Top deals as a table
        {
          title: "Top Open Deals",
          layout: "TABLE",
          item_amount: 0,
          content: "Current top deals by value.",
          table: crmData.topDeals, // 2D array, first row = headers
        },

        // Slide 4 — Win/loss as a side-by-side comparison
        {
          title: "Why We're Winning & Losing",
          layout: "COMPARISON",
          item_amount: 2,
          content: `Why we win: ${crmData.winLoss.winReasons}. Why we lose: ${crmData.winLoss.lossReasons}.`,
        },

        // Slide 5 — Quarter progress as a milestone timeline
        {
          title: "Q1 Progress",
          layout: "MILESTONE",
          item_amount: 3,
          content: crmData.quarterMilestones,
        },

        // Slide 6 — Closing slide
        {
          title: "Thanks",
          layout: "THANKS",
          item_amount: 0,
          content: "",
        },

      ],
    }),
  }
);

const { task_id } = await response.json();

Polling for the Result

Generation is async. Poll the task status until it completes:

async function waitForPresentation(taskId) {
  const statusUrl = `https://api.slidespeak.co/api/v1/task/${taskId}`;

  while (true) {
    const res = await fetch(statusUrl, {
      headers: { "X-API-Key": process.env.SLIDESPEAK_API_KEY },
    });
    const data = await res.json();

    if (data.task_status === "SUCCESS") {
      // Use request_id with the download endpoint for a short-lived URL
      return data.task_result.request_id;
    }

    if (data.task_status === "FAILURE") {
      throw new Error("Presentation generation failed");
    }

    await new Promise((r) => setTimeout(r, 5000)); // poll every 5s
  }
}

const requestId = await waitForPresentation(task_id);
const downloadUrl = `https://api.slidespeak.co/api/v1/presentation/download/${requestId}`;
console.log("Deck ready:", downloadUrl);

What the Agent Just Built

In about 45 seconds, the agent produced a 6-slide .pptx with:

A BIG_NUMBER slide showing the four headline KPIs at a glance
A FUNNEL slide showing the deal pipeline stage-by-stage
A TABLE slide with the top open deals, formatted with headers
A COMPARISON slide putting win reasons and loss reasons side by side
A MILESTONE slide tracking Q1 progress across three months
A THANKS closing slide

No human wrote a single word of the deck. No one touched slide design. The agent owned the data, defined the structure, and SlideSpeak handled all the formatting, layout rendering, and visual design.

Why Slide-by-Slide Is the Right Mode for Agents

The agent knows the data. When an agent has pulled 18 deals from a CRM, it knows the right layout for that data is a table — not bullet points. Slide-by-slide lets it say so explicitly.

Layouts carry intent. A FUNNEL layout communicates pipeline conversion. A BIG_NUMBER layout draws the eye to metrics. A COMPARISON layout frames contrast. When the agent chooses the layout, that intent is preserved in the final visual output.

Outputs are consistent. Prompt-based generation varies in structure across runs. Slide-by-slide is deterministic: same input structure, same deck structure, every time. That’s what you need for a recurring automated report.

It scales to any data source. The slide-by-slide API accepts any structured content — strings, 2D arrays for tables, chart objects with typed data series. Whatever an agent can pull from a database or API, it can pass directly as slide content.

Building a Full Agentic Pipeline

Here’s how a fully automated weekly sales report pipeline looks end-to-end:

1. Trigger: scheduled job fires every Friday at 4pm
2. Agent fetches deal data from CRM (Salesforce, HubSpot, Pipedrive...)
3. Agent fetches qualitative notes from Slack or meeting transcripts
4. Agent calls SlideSpeak slide-by-slide API with CRM data
5. SlideSpeak returns .pptx download link
6. Agent emails the finished deck to the sales team

Nobody touched a slide. The agent owns steps 1–3 and 6. SlideSpeak owns 4–5.

Using SlideSpeak from Claude Desktop or Cursor (MCP)

If you prefer working conversationally rather than building a code pipeline, the SlideSpeak MCP server lets you generate presentations directly from inside Claude Desktop, Claude Code, or Cursor — just by asking in natural language.

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "slidespeak": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.slidespeak.co/mcp",
        "--header",
        "Authorization: Bearer YOUR-SLIDESPEAK-API-KEY-HERE"
      ],
      "timeout": 300000
    }
  }
}

Then just tell Claude what you want:

“Using our Q1 CRM data, create a 6-slide sales report. Use big number slides for the KPIs, a funnel for the pipeline, and a table for the top 5 open deals.”

Claude calls SlideSpeak in the background and returns a .pptx download link — right inside the chat.

Slide-by-Slide: Full Parameter Reference

Each slide object in the slides array supports:

Parameter	Type	Required	Description
`title`	string	✅	Slide heading
`layout`	string	✅ (or `layout_name`)	Layout type — see table above
`item_amount`	integer	✅	Number of content items; must match layout constraints
`content`	string	✅	Text content for the slide
`images`	array	optional	`[{ type: "stock"/"url"/"ai", data: "..." }]`
`chart`	object	optional	Structured chart config for `CHART` layout
`table`	string[][]	optional	2D array for `TABLE` layout; first row = headers

Top-level request parameters:

Parameter	Values	Default	Description
`template`	string	`DEFAULT`	Template name or branded template ID
`language`	string	`ORIGINAL`	Output language
`fetch_images`	boolean	`true`	Include stock photos
`verbosity`	`concise` / `standard` / `text-heavy`	`standard`	Text density per slide
`include_cover`	boolean	`true`	Auto-add a cover slide
`include_table_of_contents`	boolean	`true`	Auto-add a TOC slide
`add_speaker_notes`	boolean	`false`	Generate speaker notes per slide

Getting Started

Get an API key at slidespeak.co/slidespeak-api
Install the skill:
- Claude Code / Cursor / Codex: npx skills add SlideSpeak/skills
- OpenClaw / ClawdBot: claw install slidespeak from clawhub.ai
- Manual: clone github.com/SlideSpeak/skills
Set your key: export SLIDESPEAK_API_KEY=your-key
Browse more skills at skills.sh and clawhub.ai
Try the MCP for Claude Desktop / Cursor: github.com/SlideSpeak/slidespeak-mcp

For the full API reference including charts, webhooks, and branded templates, visit docs.slidespeak.co.

The best agent setups in 2026 aren’t just thinking — they’re delivering finished, usable outputs. The SlideSpeak Agent Skill is how you make presentations part of that output. Pull data from anywhere, define your layouts, and get a finished deck. No human formatting required.

Questions or feedback? Find us at slidespeak.co.