How to Generate Presentations with Hermes Agent + 2Slides (Complete Setup Guide)

Hermes Agent — the self-improving autonomous agent from Nous Research — pairs natively with 2Slides via the open agentskills.io skill standard. Install the slides-generation-2slides-skills package into

, add your 2Slides API key to the environment, and Hermes can generate a full 16:9 deck from a single sentence in 30–60 seconds. The same installation also exposes seven 2Slides API endpoints — text-to-slides, PDF-to-slides, reference-image style matching, multi-speaker narration, theme search, job polling, and asset export — as first-class Hermes tools. Because Hermes has a closed learning loop that writes new skills from experience, it actively refines how it uses 2Slides over time: picking better themes for your audience, preferring 4K output for investor decks, switching to Create-Like-This when you paste a screenshot, and scheduling recurring reports without being asked twice. This guide walks through installation, the five most common invocation patterns, direct API usage for power users, and the gotchas that trip up most first-time integrations.

What is Hermes Agent?

Hermes Agent is an autonomous, server-resident AI agent built by Nous Research. Unlike IDE-embedded copilots or chatbot wrappers, Hermes runs as a long-lived process on your server (or a $5 VPS), accumulates memory across sessions, and — uniquely — writes its own skills from experience. It is model-agnostic (works with Nous Portal, OpenRouter, OpenAI, Anthropic, NVIDIA NIM, or custom endpoints), ships with 40+ built-in tools, supports MCP server integration, and exposes a single gateway that lets you message it via Telegram, Discord, Slack, WhatsApp, Signal, email, or CLI. Source: github.com/NousResearch/hermes-agent.

The feature that makes Hermes interesting for presentation workflows specifically is its closed learning loop: after each complex task, Hermes can create a reusable skill, then improve that skill during later use. This is the exact loop that makes slide generation get better over time.

Why pair Hermes with 2Slides?

The combination is unusually synergistic for three reasons:

1. Hermes has no native slide tool. Its 40+ built-in tools cover web search, browser automation, vision, image generation, TTS — but not deck authoring. 2Slides fills the exact capability gap.
2. 2Slides exposes its full API as tools, not just one endpoint. The 2Slides skill package wraps seven distinct generation modes (text, PDF import, reference-image cloning, narration, export, theme search, status polling), so Hermes can pick the right mode based on intent instead of forcing every request through a single generate endpoint.
3. Hermes' self-improvement loop refines the integration over time. The first time you ask for a deck, Hermes calls
   generate
   with defaults. By the fifth time, it has learned that your Q1 board decks need 4K, your all-hands need 16:9, and your customer updates need multi-speaker narration — and it writes those preferences into an auto-generated follow-on skill.

This is a genuinely different pattern from the Claude MCP integration, where the LLM calls tools statelessly. Hermes remembers.

Prerequisites

Before you start you need:

• A Linux/macOS machine or VPS with Python 3.10+ and Bash
• A 2Slides account and API key — sign up at 2slides.com/api (new accounts receive 500 free credits, enough for ~50 text-to-slide pages or 5 Nano Banana 2K pages)
• An LLM provider key (Nous Portal, OpenRouter, OpenAI, or Anthropic) that Hermes will use for its reasoning loop
• Roughly 15 minutes for first-time setup

Step 1 — Install Hermes Agent

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrc
hermes setup

The

wizard asks for your LLM provider, default model, and optional messaging-gateway credentials (skip gateway setup on your first pass — you can enable Telegram/Slack later). After setup finishes, confirm the install with — you should drop into an interactive CLI prompt.

Step 2 — Install the 2Slides skill

The 2Slides skill lives at github.com/2slides/slides-generation-2slides-skills and follows the open agentskills.io standard that Hermes natively supports. Drop it into the user skills directory:

mkdir -p ~/.hermes/skills
cd ~/.hermes/skills
git clone https://github.com/2slides/slides-generation-2slides-skills.git slides-2slides

Then add your 2Slides API key to your shell environment so the skill scripts can authenticate:

echo 'export SLIDES_2SLIDES_API_KEY="sk-2s-..."' >> ~/.bashrc
source ~/.bashrc

Restart the Hermes CLI and type

— you should see in the list with its seven available functions (generate, create-pdf-slides, create-like-this, generate-narration, download-slides-pages-voices, search-themes, get-job-status).

Step 3 — Generate your first deck

The simplest invocation is a natural-language request inside Hermes:

> Create a 10-slide presentation about the State of AI Agents in 2026, focusing on autonomous agents vs chatbots, and use a modern dark theme

Hermes will:

1. Call
   search-themes
   with the query "modern dark" to pick a theme ID
2. Call
   generate
   with your content and that theme
3. Poll
   jobs/:id
   every 5 seconds until the job completes
4. Return a shareable
   slideUrl
   and a
   pdfUrl

Total wall-clock time for a 10-page deck: 30–60 seconds in sync mode. The response includes the

, page count, and generation mode.

The five most useful invocation patterns

Not every request should go through

. The 2Slides skill exposes distinct modes so Hermes (and you) can pick the right one. Here are the five you will use most often, with example prompts:

All endpoints share the same async envelope — submit → get

→ poll → receive file URLs. This consistent shape is why Hermes handles them cleanly as a skill set rather than seven incompatible tools.

Direct API usage (for custom tools)

If you want to build a custom Hermes tool instead of using the packaged skill — for example, a domain-specific "Generate quarterly OKR deck with our brand theme" tool — you can call the 2Slides API directly from a Python script Hermes executes.

A minimal generate-and-wait pattern:

import os, time, requests

API = "https://2slides.com/api/v1"
H = {"Authorization": f"Bearer {os.environ['SLIDES_2SLIDES_API_KEY']}"}

resp = requests.post(f"{API}/slides/generate", headers=H, json={
    "content": "Q1 2026 board update: ARR, retention, roadmap",
    "themeId": "theme_modern_dark",
    "mode": "async",
    "aspectRatio": "16:9",
    "resolution": "2K",
}).json()

job_id = resp["jobId"]
while True:
    job = requests.get(f"{API}/jobs/{job_id}", headers=H).json()
    if job["status"] in ("completed", "failed"):
        break
    time.sleep(5)

print(job["slideUrl"], job["pdfUrl"])

See Build an AI Presentation Agent: Developer Guide for the full async-job architecture and retry patterns. For system-prompt patterns Hermes uses to decide between modes, see System Prompts for AI Presentation Agents.

The self-improvement loop in action

Here is the pattern that separates Hermes from other agent runtimes. The first time you ask for a customer-facing deck, Hermes produces something generic. But Hermes can — and will — create a follow-on skill after the task completes:

/skills new customer-update-deck

The auto-generated skill captures what worked: the theme ID you approved, the aspect ratio, the voice name for narration, the specific phrasing you asked for in the opening slide. Next time you say "customer update deck," Hermes invokes this skill instead of the raw

function. Over ten iterations the skill accumulates preferences that a stateless tool would never remember.

This is why pairing a self-improving agent with a multi-endpoint API — rather than a single-shot generator — matters. The learning loop has something to learn against.

Scheduling recurring slide jobs

Hermes ships with a built-in cron scheduler. You can set up a recurring job in one line:

> Every Monday at 9am, generate a weekly status deck from our internal status doc, add narration with the Puck voice, and post the PDF to #exec-updates on Slack

Hermes stores this as a scheduled task (

to inspect) and executes it autonomously. Because the messaging gateway supports Slack, Discord, Telegram, and WhatsApp natively, the finished deck can land in any channel without additional integration work — the deck link or PDF arrives as a bot message on the platform you specified.

Common issues and fixes

Skill not appearing in

. Confirm the clone is under and that is at the top level of that directory. Run to refresh.

"401 Unauthorized" from 2Slides. The

environment variable is not visible to the skill's Python subprocess. On macOS launchd, add the key to (which Hermes sources unconditionally) rather than .

Deck generation stuck in

for >120 seconds. You probably submitted in sync mode during peak hours. Re-submit with and poll — async requests are queued independently and typically complete in under 90 seconds even under load.

Narration fails after generation succeeds. Narration requires the

from a completed generation job, not the . Check that the Hermes skill is passing (UUID) not the deck URL.

Hermes picks the wrong theme. Early in the learning loop this is normal. After you correct the theme once or twice, Hermes writes a preference into its memory and does the right thing on future calls. You can accelerate this by telling it directly: "remember that all my customer decks should use the Executive Minimal theme."

Frequently Asked Questions

Does Hermes Agent work with 2Slides on the free plan?

Yes. New 2Slides accounts get 500 free credits, which covers roughly 50 pages of standard text-to-slide generation (10 credits/page) or about 5 Nano Banana 2K pages (100 credits/page) or ~2 pages of fully narrated output (210 credits/page). Hermes itself is MIT-licensed and free; you only pay for the LLM provider you route it to.

Is the 2Slides skill an MCP server or an agentskills.io skill?

It is an agentskills.io skill — the open standard Hermes, OpenClaw, and several other agents natively support. 2Slides also ships a separate MCP server (see How MCP Is Changing Presentation Workflows), but for Hermes specifically, the skill package is the faster path because it lands directly in

without any MCP server process to manage.

How is this different from using Claude + 2Slides MCP?

Claude via MCP calls tools statelessly — every conversation starts fresh. Hermes maintains persistent memory and writes new skills from experience, so the integration gets better over time rather than repeating the same defaults on every call. For one-off generations, the two approaches are equivalent. For recurring workflows (weekly reports, monthly board decks, recurring customer updates), Hermes' learning loop materially outperforms because it captures preferences that a stateless agent has to be told every time.

Can Hermes hand off deck delivery to Slack or Telegram automatically?

Yes. Hermes' single-gateway architecture means the same process that generated the deck can message it back to any connected platform. After you configure the Telegram or Slack gateway via

, a prompt like "generate this deck and post the PDF to #board-updates on Slack" works end-to-end without any additional integration — Hermes calls 2Slides, polls the job, downloads the PDF, and posts it to the channel.

What languages and output resolutions are supported?

The 2Slides skill supports 19 languages (Auto, English, Spanish, French, German, Italian, Portuguese, Russian, Japanese, Korean, Chinese Simplified/Traditional, Arabic, Hindi, Indonesian, Vietnamese, Turkish, Polish, Thai, Greek), resolutions 1K / 2K / 4K, and aspect ratios from 1:1 through 21:9 including portrait (9:16) for mobile-first audiences. Credit cost scales with resolution: 10 credits/page for Fast PPT, 100 for Nano Banana 2K, 200 for Nano Banana 4K.

Does Hermes' self-improvement loop ever overfit?

In practice, no — skills are user-scoped and human-reviewable. You can inspect auto-generated skills with

and edit or delete them with or . If Hermes over-prefers a theme or voice you no longer like, correct it once in conversation and the skill updates. For a deeper discussion of how agents like Hermes fit the broader AI automation landscape, see The Future of AI Agents in Presentation Creation and 2Slides Agent Skills: Automate AI Slide Workflows.

The Takeaway

Hermes Agent plus 2Slides is not just another "AI integration" — it is the first combination where a self-improving autonomous agent is paired with a multi-endpoint presentation API that has enough surface area to learn against. Every other pairing is either a stateless tool call (Claude MCP, ChatGPT plugins) or a single-endpoint generator with no capability breadth to refine. Hermes' memory plus 2Slides' seven distinct endpoints is the shape that actually rewards the learning loop.

The practical path in 2026 is: install both in 15 minutes, generate three or four decks manually so Hermes observes your preferences, then let the scheduler take over. Within a month Hermes is producing your weekly report, quarterly board deck, and customer-update deck on autopilot — with your theme, your voice, your aspect ratio, and your delivery channel — because it wrote the skill for each one itself.

Ready to hand off your deck workflow? Get a 2Slides API key (500 free credits) and install Hermes Agent today — full setup in under 15 minutes.