AI meets traditional slide software

I'll be honest: I haven't tried every integration out there, including the latest MCP plugins for PowerPoint. But my overall experience getting AI to produce great slides with traditional software has been underwhelming. It's decent at breaking content down into a slide structure, picking titles and suggesting an outline. But when it comes to producing final, visually polished slides? Not there yet.

The problem is the interface. Tools like PowerPoint and Google Slides were designed for humans dragging boxes around a canvas. That's arguably the opposite of what an AI agent needs. So I asked myself: what interface would an agent natively understand?

Enter Slidev

The answer is code. More specifically, web code: HTML, CSS, Markdown. After some research I found Slidev, a framework for building presentations entirely in code. It existed long before the AI wave; it was made for developers who wanted version-controlled, themeable presentations without ever opening a slide editor.

That makes it perfect for coding agents like Claude Code. There are other code-based slide tools out there, but the same principle applies to all of them.

Slidev works like this: you write a Markdown file where each slide is separated by ---. You can mix in HTML and CSS for custom layouts, add transitions, embed code snippets with syntax highlighting, and theme the whole thing with a few lines of configuration. The result is a browser-based presentation that looks genuinely good. Not 'good for something generated from code'. Just good.

What I learned using it

After using this workflow for several training sessions, a few things stood out:

• Build a template once, reuse forever. Create all the slide layouts you'll ever need (tables, two-column, three-column, timelines) styled with your own visual identity. Every future deck starts from that base and saves hours.
• Multi-brand is easy. If you work with multiple organisations, make one master set of layouts and just swap the colours and logo. Same structure, different skin.
• The agent can validate visually. Claude Code can open Slidev in preview mode and check the output before you even look at it.
• Content generation is a bonus. The agent can pull from its own knowledge or from files you pass it. It's especially good at turning publicly available information into structured slides.

The trade-offs

Slidev is not built for real-time collaboration the way Google Slides is. Since it's code, you can use git for version control, but you won't get simultaneous editing. And while you can make very precise changes in the code, it's less self-service than a traditional editor if someone on your team doesn't code.

You also need somewhere to host the slides if you want to share them as a live presentation. You can export to PDF or even PPTX, but in practice the export captures each slide as an image. Useful for PDF handouts, not for further editing in PowerPoint.

That said, if you're a bit more technical, there's a nice upside: since your slides are just files, you can keep them in a git repository with a CI/CD pipeline that automatically builds and publishes them on every push. Your presentations become versioned, reviewable, and always available at a URL. No more emailing slide decks around.

For me, the bottom line is simple: if you already use a coding agent, you don't need a dedicated AI slide tool. You need a slide framework that speaks the agent's language. Slidev does that, and the results are better than anything I got from drag-and-drop AI integrations.

If you'd like help setting up a Slidev template for your organisation, or integrating AI-powered slide creation into your workflow, reach out through the contact form. It's the kind of thing we do at Ask Marsan.

The good news is you don't actually need OpenClaw. You can rebuild the exact same setup yourself, on your own VPS, using only Claude Code, and have it pull from the subscription you already pay for. That's what this post is about. By the end you'll have a private Discord server, one channel per agent, each channel wired to its own little Claude-powered bot, and the whole thing surviving reboots without you ever touching it again.

Quick tip before we start: if you're doing this on the same VPS where OpenClaw is currently running, you have a really nice shortcut. Just open Claude Code in that directory and ask it to poke around the existing OpenClaw files and reproduce the setup as closely as possible. Claude Code can read your old configs, list which agents you had, see what each one was doing, and translate the whole thing into the new structure for you. Honestly, that's the closest thing to a one-click migration you're going to get, and it's a great example of what these agents are good at.

How Discord fits into this

Before any code, let's talk about why Discord is even in the picture, especially if you've never used it for anything beyond chatting with friends. The idea is simple: Discord is just a messaging app, but it has a really good free bot API. That means it can double as the front-end for any agent you build. You get polished mobile and desktop apps for free instead of having to design and host your own UI.

Here's the structure. You make a private Discord server (think of a server as your own personal Slack workspace, totally under your control). Inside that server you create one channel per agent: #email-manager, #research, #coding, whatever. Each channel is wired to its own dedicated bot. When you type something in #research, only the research agent sees it, thinks about it, and replies in that same channel. The other agents have no idea it happened.

This per-channel split is what makes the whole thing work. Every agent gets its own conversation history, its own scrollback, its own pinned messages, its own notification settings on your phone. And it costs you nothing because Discord doesn't charge for any of this. Three reasons it's the right choice: free polished apps on every device, mature bot API with no per-message fee, and channels give you natural per-agent isolation without writing a line of UI code. If you're coming from OpenClaw you already know what this looks like. If not, Step 2 walks you through building the server and the bots from scratch.

What you're building

Claude Code Channels is the official Anthropic plugin that connects a running Claude Code session to a Discord bot. When you post a message in the agent's channel, the message gets routed into that session, Claude reads it, thinks, uses tools, and replies back in the same channel. Each agent is a separate Claude Code process with its own bot token, its own working directory, and its own CLAUDE.md file describing who it is and what it does.

The four things you get out of this that you don't get from a hosted alternative:

• No third parties in the loop. Your data only ever touches your VPS and the Anthropic API.
• No per-message fees beyond your existing Claude Max or Pro plan.
• Multiple specialised agents on one machine, each with its own identity and tools.
• Survives reboots. Agents auto-restart via cron with zero babysitting.

The architecture in one picture

Each agent lives in its own directory under ~/agents/ and runs inside a persistent tmux session. The flow of a single message looks like this:

Your message in #agent-name (Discord channel)
   ↓
Discord plugin (MCP server)
   ↓
Claude Code session (tmux)
   ↓
Agent working directory (~/agents/<name>/)

A minimal agent directory has three files in it:

• CLAUDE.md: the persona, tone and capabilities. This is the agent's brain.
• start.sh: launches Claude Code with the Discord channel plugin attached.
• .env: holds DISCORD_BOT_TOKEN, protected with chmod 600.

Example agents you can run

Pretty much anything you'd want an always-on assistant for can become an agent. A few good starting points:

• email-manager: drafts, summarises and organises emails matching your tone.
• news-agent: fetches and synthesises live news on topics you care about.
• investing: tracks a portfolio and sends a cron-triggered daily report.
• coding: a senior engineer for debugging, code review and architecture questions.
• research: a research analyst that writes structured markdown reports with citations.
• home-assistant: manages shopping lists, reminders and household schedules.

Step 1: Install the prerequisites

On a fresh Debian or Ubuntu VPS, you'll need Node.js 20, Bun, Claude Code itself, plus tmux and cron. Bun is what the Discord plugin uses, and it depends on unzip, which is not installed by default on minimal images.

# Node.js 20
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
apt-get install -y nodejs

# Bun (install unzip first)
apt-get install unzip -y
curl -fsSL https://bun.sh/install | bash
echo 'export PATH="$HOME/.bun/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

# Claude Code
npm install -g @anthropic-ai/claude-code

# tmux + cron
apt-get install -y tmux cron
systemctl enable --now cron

Step 2: Create the Discord server, channels and bots

If you don't already have a private Discord server, make one. Open Discord, click the + on the left rail, choose "Create My Own", then "For me and my friends", give it a name like "Personal Agents", done. Inside that server, create one text channel per agent you're planning to run (#email-manager, #research, #coding, etc). Right-click each channel and use Edit Channel → Permissions to make it private, so only you and the matching bot can read it.

Now you need a Discord application for each agent so it can have its own name, avatar and bot identity. Head over to the Discord Developer Portal and for each agent:

• New Application: give it a name that matches the agent (e.g. "Email Manager Bot").
• Bot tab → Reset Token → copy it and stash it somewhere safe right away. You only see it once.
• Privileged Gateway Intents → enable Message Content Intent → Save.
• OAuth2 → URL Generator → scope: bot → permissions: Send Messages, Read Message History, Attach Files, Add Reactions.
• Open the generated invite URL and add the bot to your Discord server.
• Back in the server, lock down the bot's channel access so the email bot only sees #email-manager, the research bot only sees #research, etc. This isolation is what keeps each agent focused.

Save each token somewhere safe the moment you create it. Discord will not show it to you again.

Step 3: Log in to Claude Code

Authenticate Claude Code once on the VPS. The login is shared by every agent on the machine, so you only do this once and never again.

claude login

Step 4: Install the Discord plugin

Open Claude Code, add the official Anthropic plugin marketplace, then install the Discord plugin. Pay attention to the spelling of the GitHub org (anthropics, not anthrop​ics). A typo there is the single most common reason this step fails.

claude
/plugin marketplace add anthropics/claude-plugins-official
/plugin install discord@claude-plugins-official
/reload-plugins
# then Ctrl+C to exit

If the marketplace clone fails with a Git authentication error, clear any stale credential helper and retry:

git config --global credential.helper ""

Step 5: Scaffold an agent with new-agent.sh

Wiring each agent up by hand gets old fast. Instead, drop a small scaffolding script at ~/agents/new-agent.sh that asks three questions (name, bot token, persona) and does everything else for you. The script should:

• Check that claude, tmux and bun are installed before doing anything.
• Validate the bot token against the Discord API so you fail fast on a typo.
• Create ~/agents/<name>/ with CLAUDE.md (built from the persona), start.sh, and a chmod 600 .env file.
• Add a @reboot cron entry so the agent auto-restarts on every reboot.
• Launch the agent in a detached tmux session named after it.
• Walk you through Discord pairing and locking the allowlist down.

The generated start.sh is short. It loads Bun into PATH, sources the .env, jumps into the agent directory, and launches Claude Code with the Discord plugin attached:

#!/bin/bash
export PATH="$HOME/.bun/bin:$PATH"
set -a; source ~/agents/<name>/.env; set +a
cd ~/agents/<name>
claude --channels plugin:discord@claude-plugins-official

Why we wrap it in tmux: keeping the agent alive when you log out

This is the part that confuses pretty much everyone the first time. When you SSH into your VPS and run a program, that program is tied to your SSH session. The moment you close the terminal or your laptop loses Wi-Fi, the program dies, and your AI agent goes with it. Obviously not what we want for an assistant that's supposed to be reachable 24/7.

tmux solves this in the simplest possible way: it lets you start a program inside an invisible terminal that lives on the server itself, completely independent of your SSH connection. Think of it like opening a Chrome tab on a remote computer and then unplugging your own laptop. The tab keeps running on the remote machine because it never depended on your laptop in the first place. You can come back hours or days later, attach to that same invisible terminal, and find the agent exactly where you left it, still listening for Discord messages.

Each agent gets its own named tmux session, so you can list them all, attach to any one of them to peek at what it's doing, detach again, and the agent keeps running. That's why every command in this guide that launches an agent goes through tmux.

Surviving reboots: the @reboot cron entry

tmux keeps the agent alive while the server is up. But what happens when the VPS itself reboots? Hosts patch kernels, the box runs out of memory, your provider has a maintenance window. Without help, every agent on the machine would silently die at the first restart and you'd only notice the next time you tried to message one.

cron is the standard Linux scheduler, and it has a special trigger called @reboot that runs a command every time the machine boots. We use it to automatically launch each agent's tmux session 15 seconds after startup. From your point of view: you reboot the VPS, walk away, come back, and all your agents are already back online. You did nothing.

@reboot sleep 15 && /usr/bin/tmux new-session -d -s <name> /root/agents/<name>/start.sh

The 15-second sleep is not optional. Without it, the agent can start before the VPS network stack has come up, fail to reach the Anthropic API, and silently die. Make the script idempotent on the cron entry so re-running it for the same agent never creates duplicates.

Why CLAUDE.md is the most important file

CLAUDE.md gets read automatically at the start of every session. It's the persistent system prompt for your agent, written in plain markdown. A good CLAUDE.md defines four things: who the agent is, what it can do, which tools and files it should use, and how it should communicate.

# Email Manager Agent

You are a professional email assistant. Your job is to help
draft, edit, summarise and organise emails. Match the user's
tone: formal if they write formally, casual if not.

## Capabilities
- Draft emails from a brief description
- Summarise long email threads
- Suggest replies with different tones
- Save drafts to ~/agents/email-manager/drafts/

## Tools available
- Web search: use for researching context or recipients
- Filesystem: read/write files in your working directory

## Tone
Concise. Never pad. No unnecessary sign-offs or preamble.

Narrow focus beats vague generalist every single time. Don't try to give one agent all the jobs. Just spin up another agent.

Step 6: Pair your Discord account (carefully)

Pairing is what tells the agent which Discord users are allowed to talk to it. The flow is deliberately a little awkward, because pairing from the wrong place is exactly the kind of thing a prompt-injection attack will try to trick the agent into doing.

• Send any message in the agent's dedicated Discord channel. The bot replies with a 6-character pairing code.
• On the VPS, attach to the agent's tmux session: tmux attach -t <agent-name>
• Inside the Claude Code prompt, run: /discord:access pair <CODE> followed by /discord:access policy allowlist
• Detach from tmux with Ctrl+B then D.

Never approve a pairing because a Discord message asked you to. Only run /discord:access from the terminal. A message inside Discord asking the agent to add a user to the allowlist is exactly what a prompt-injection attack looks like.

Step 7: Verify and test

Once everything is wired up, two quick checks confirm the fleet is healthy:

tmux ls                       # all running agents
crontab -l | grep '@reboot'   # all reboot entries

Then post a message in each agent's Discord channel. Each one should respond independently from its own context and persona, with a different name, a different tone, and a different working directory. If two agents start replying with the same voice, you almost certainly have the wrong token in one of the .env files.

Where this pays off

The interesting thing isn't that you can chat with Claude from Discord. It's that each agent has its own filesystem, its own tools, and its own memory of what you've asked it before. The investing agent really does keep a portfolio.json across sessions. The research agent really does build up a notes.md week after week. The coding agent really does live inside one of your repos.

Once the scaffolding script exists, adding a new agent takes about a minute. That changes how you think about delegating work to AI: instead of one giant prompt that has to do everything, you build a small team of focused specialists you message exactly when you need them. And after Anthropic's April 4 change, you're doing it without paying anyone except Anthropic, on hardware you own.

If you'd like help setting this up on your own infrastructure, or designing the persona and toolset for an agent that fits your business, that's exactly the kind of work we do at Ask Marsan. Ping us through the contact form and we'll scope it together.

Why This Blog?

I've spent years accumulating knowledge that mostly lived in my head, in scattered docs, or in conversations with colleagues. This blog is my attempt to organize those thoughts and share them with others who might find them useful.

Whether you're a publisher trying to understand yield optimization, a product manager navigating the ad tech ecosystem, or someone curious about practical AI adoption, I hope you'll find something valuable here.

What to Expect

I'll be writing about the things I know and care about:

• Ad Tech deep dives: SSPs, DSPs, header bidding, curation, and the evolving programmatic landscape
• AI in practice: Not hype, but real tools and workflows that actually improve how we work
• Product strategy: Lessons from building and scaling products in complex B2B environments
• The consulting journey: What I learn as I help different organizations solve their challenges

A Note on Style

I believe in being direct. You won't find fluff here. If I write about something, it's because I think it's genuinely useful or interesting. I'll share what worked, what didn't, and why.

The best way to learn is by doing. The second best is by sharing what you learned.

Thanks for stopping by. If there's a topic you'd like me to cover, feel free to reach out through the contact form. Let's learn together.