Instagram carousels on autopilot. A Claude agent does it all – from topic to published post

Section 01Why carousels are the strongest format right now

The short answer: Instagram currently gives carousels two privileged reach channels at once. Every carousel post lands in your followers' main feed and in their Explore. And since last year's algorithm update, it also lands in the Reels feed if you attach trending audio. That means the reach of a Reel plus the depth of a carousel.

The 2026 numbers look roughly like this. Carousel engagement rate averages 1.92%. Single image: 0.45%. Reels: 0.5%. Carousel save rate runs 2–3x higher than any other format. And for the algorithm, a save is the strongest signal of value. Stronger than a like, stronger even than a comment.

Why the algorithm loves carousels

• Time on post – a person swipes, reads, looks. A carousel takes 30–60 seconds versus 3 seconds for a single photo. The algorithm logs that watch time and boosts reach
• The second pass – if someone doesn't swipe on the first impression, Instagram gives the carousel another shot. It shows up again starting from a different slide. One post = two impressions from different angles
• Save rate – checklists, frameworks and breakdowns get saved as bookmarks. A save beats a like, so every save pushes the post up in the feed
• DM shares – a carousel is easy to forward to a friend with a "check this out." A share to DMs is the strongest signal for the algorithm after a save

Why you can't do one a day by hand

Let's add up the minimum time a carefully made carousel takes:

• Picking a topic and checking you haven't done it yet – 10 minutes
• Structure: cover hook, 5–7 slides, CTA, caption – 25 minutes
• Designing the cards in Figma or Canva – 30–40 minutes
• Approving it yourself (reread, fix) – 10 minutes
• Publishing: upload, pick audio, hashtags – 10 minutes

That's 1.5 hours a day, 45 hours a month. An expert doesn't have that kind of free time. So either you skip carousels and lose the strongest format, or you hire a designer and a copywriter for $700–1,100/mo and try to keep them in sync. Or you build an agent – which is what's next. On top of carousels it's worth building a full content pipeline from 10 AI prompts for experts, where one voice note in the morning turns into a week of posts across five platforms.

Section 02Agent architecture: what the pieces are

Before we dive into the steps – the big picture. A carousel agent is six components working together on one VPS.

That's ~$25/mo for the stack itself. A single post that pulls 3 leads into your channel pays for a quarter's subscription in advance.

The full cycle in one day

That's it, your day has started. Your Instagram content is live, and you spent 5 minutes approving it instead of 1.5 hours doing it by hand.

Section 03Installing Claude Code on a VPS

If you already have a working VPS with Claude Code – skip this section and jump to the fourth. If not, here's the full path from nothing to a working agent on the server.

adduser marketer
usermod -aG sudo marketer
mkdir -p /home/marketer/.ssh
cp ~/.ssh/authorized_keys /home/marketer/.ssh/
chown -R marketer:marketer /home/marketer/.ssh
chmod 700 /home/marketer/.ssh
chmod 600 /home/marketer/.ssh/authorized_keys

sudo apt update && sudo apt upgrade -y
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs python3 python3-pip python3-venv git tmux
sudo npm install -g bun

npm install -g @anthropic-ai/claude-code

mkdir -p ~/workspace
cd ~/workspace
git init

Section 04A Telegram bot for approvals via MCP plugin

For Claude to send you ideas and take your reply, you need a Telegram bot connected to Claude through MCP (Model Context Protocol). It's free and takes 15 minutes to set up.

/newbot
Bot name: Marketing Agent
Username: @your_marketing_agent_bot
<BotFather sends a token like: 7891234567:AAxxxxxx>

claude /plugin install telegram

claude -p "Send the message 'test' to the Telegram chat"

Section 05Connecting Instagram through the Meta Graph API

For the agent to publish to Instagram automatically, you need an official connection through the Meta Graph API. This is the longest step in the whole setup (45–60 minutes), because Meta built a complicated approval system. But you only do it once, and after that it runs itself.

curl "https://graph.facebook.com/v19.0/oauth/access_token?\
grant_type=fb_exchange_token&\
client_id=<APP_ID>&\
client_secret=<APP_SECRET>&\
fb_exchange_token=<SHORT_LIVED_TOKEN>"

curl "https://graph.facebook.com/v19.0/me/accounts?access_token=<LONG_TOKEN>"

curl "https://graph.facebook.com/v19.0/<PAGE_ID>?\
fields=instagram_business_account&access_token=<LONG_TOKEN>"

cd ~/workspace
nano .env
# Contents:
META_LONG_TOKEN=<long-lived token>
META_APP_ID=<App ID>
META_APP_SECRET=<App Secret>
IG_BUSINESS_ID=<Instagram Business ID>

Section 06The prompt for morning idea generation

The most important part is the quality of the ideas that arrive in the morning. If the agent serves up "generic marketing topics," you'll reject them forever. If the ideas hit your audience's nerve and use a fresh news hook, you tap "pick" on the first try.

The prompt itself is an instruction file the agent reads every morning. Mine lives at ~/workspace/cron-tasks/prompts/ideas-daily.md. Here are the key blocks.

Block 1: Loading context

Before generating, the agent reads a few files:

• Blog concept – one page: what you write about, who the audience is, what the tone is. For example: "Online experts, $10K–100K/mo revenue, tone is direct, no fluff"
• Content pillars – the 6 categories you publish in: AI, funnels, personal brand, school case studies, personal, tools
• Idea history – a log of everything used in the last 30 days. So it doesn't pitch the same thing twice
• Style – tone rules from your posts: which phrasings you like, which you avoid, how long the hook should be

Block 2: Gathering news hooks

The agent gathers fresh news through WebSearch:

• AI news from the last 24–48 hours: model releases, controversies, viral demos
• Google Trends for today: viral cultural moments – celebrities, memes, sports events
• What's being discussed on Reddit r/popular and in the niche's leading channels

Why the cultural trends matter: one of the 3 ideas should be "AI × cultural moment" – the format with the highest viral potential. For example: "Bieber performed at Coachella with a deepfake of his dad" – which turns into an idea like "3 AI tools any creator could use for the same effect."

Block 3: Strict fact-checking

Before generating ideas, the agent verifies every number and name through at least 2 independent sources. If a fact doesn't hold up, it drops the idea. This is the key defense against hallucinations.

Block 4: Output format

The agent returns 3 Reel ideas and 3 carousel ideas in one message. The structure of each idea:

🎴 Cover hook in one line
Category: [one of the 6 pillars]
What the slides cover: [3-5 key points]
Why it'll land: [save / share / debate in the comments]

At the end of the message – a prompt to reply "R1 C2" or "R2 C3," and a note that "sources verified."

Running it every morning

A cron job on the server calls a wrapper script run-task.sh, which runs Claude in non-interactive mode with this prompt:

# crontab -e
0 13 * * * /home/marketer/workspace/cron-tasks/run-task.sh ideas-daily \
  /home/marketer/workspace/cron-tasks/prompts/ideas-daily.md

0 13 * * * is 1:00 PM UTC, which is 8:00 AM US Eastern. Change it to fit your time zone.

Section 07The prompt for slide copy

When you reply "C2," the agent takes idea #2 from the morning batch and runs the second prompt. This prompt writes the final copy for all the slides plus the caption and hashtags.

What the agent does, step by step

Section 08Designing the cards with HTML+CSS+Playwright

This is the prettiest part of the whole system. The agent designs the cards not in Figma and not in some AI image generator, but by hand – with HTML+CSS, rendered to PNG through Playwright.

Why this approach: typography renders perfectly (AI image models still mangle text), typos in tool names and prices are impossible, it's free, you can edit in real time, and the brand standard is guaranteed.

The stack

• HTML5 + CSS3 by hand, no frameworks
• Google Fonts: Inter (400-900) for headings, Fraunces (italic) for accents, JetBrains Mono for labels and numbers
• Playwright (Python sync_api) to render to PNG
• Slide templates live in ~/workspace/carousel-templates/

The cover slide template

One HTML file = one slide. The structure is minimal:

<!doctype html>
<html lang="en">
<head>
  <link href="https://fonts.googleapis.com/css2?family=Inter:[email protected]&family=Fraunces:ital@1&display=swap" rel="stylesheet">
  <style>
    body{
      width:1080px;height:1350px;margin:0;padding:80px;
      background:#06070E;color:#fff;
      font-family:'Inter',sans-serif;
      display:flex;flex-direction:column;justify-content:space-between;
    }
    h1{font-weight:900;font-size:104px;line-height:0.96;
       letter-spacing:-0.045em;text-wrap:balance;}
    h1 em{font-family:'Fraunces';font-style:italic;color:#FFCD1F;}
    .number{font-weight:900;font-size:340px;color:#FFCD1F;
            letter-spacing:-0.06em;line-height:0.85;}
  </style>
</head>
<body>
  <h1>5 prompts for Claude.</h1>
  <div class="number">−10</div>
  <div>hours a week for every expert</div>
</body>
</html>

Rendering to PNG with Playwright

from playwright.sync_api import sync_playwright
from pathlib import Path
import time

DIR = Path("/home/marketer/workspace/carousel-output/2026-05-02")
slides = [f"slide-{i}" for i in range(1, 8)]

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    ctx = browser.new_context(
        viewport={"width": 1080, "height": 1350},
        device_scale_factor=2,
    )
    for name in slides:
        page = ctx.new_page()
        page.goto(f"file://{DIR}/{name}.html", wait_until="networkidle")
        page.evaluate("document.fonts.ready")
        time.sleep(1.5)
        page.screenshot(
            path=str(DIR / f"{name}.png"),
            clip={"x": 0, "y": 0, "width": 1080, "height": 1350},
        )
        page.close()
    browser.close()

device_scale_factor=2 is the retina render – the file is 2160×2700 but reads as crisp 1080×1350. Without it, text looks blurry on phones.

Brand rules (important)

The prompt for generating the card HTML

The agent gets the slide copy from you and assembles the HTML from the template itself. The prompt is roughly:

Take the slide copy from the last approved message.
For each slide:
1. Copy the closest template from ~/workspace/carousel-templates/
   (cover for the cover, prompt for text blocks, cta for the finale)
2. Replace the placeholder text with the real text
3. Save to ~/workspace/carousel-output/{date}/slide-{N}.html
After all slides, run render.py.
Check that all 7 PNGs were created and each is exactly 1080x1350.

Section 09Automatic publishing to Instagram

The finished PNGs live in ~/workspace/carousel-output/2026-05-02/. Next comes a script that uploads them to Instagram as a single carousel post through the Meta Graph API.

The publishing logic

The Meta API doesn't accept files directly – it only accepts URLs. So the process has multiple steps:

1. Put the files in a public folder on your site (or in S3/Cloudflare R2)
2. For each slide, create an IG Media Container with type IMAGE and the parameter is_carousel_item=true
3. From all the containers, create one CAROUSEL container
4. Publish the CAROUSEL container

The ready-made publishing script

import os
import requests
import time
from pathlib import Path

LONG_TOKEN = os.environ["META_LONG_TOKEN"]
IG_ID = os.environ["IG_BUSINESS_ID"]
PUBLIC_BASE = "https://blog.paulbreit.com/carousel-output/2026-05-02"

def create_image_container(image_url):
    r = requests.post(
        f"https://graph.facebook.com/v19.0/{IG_ID}/media",
        data={
            "image_url": image_url,
            "is_carousel_item": True,
            "access_token": LONG_TOKEN,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["id"]

def create_carousel(container_ids, caption):
    r = requests.post(
        f"https://graph.facebook.com/v19.0/{IG_ID}/media",
        data={
            "media_type": "CAROUSEL",
            "children": ",".join(container_ids),
            "caption": caption,
            "access_token": LONG_TOKEN,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["id"]

def publish(creation_id):
    r = requests.post(
        f"https://graph.facebook.com/v19.0/{IG_ID}/media_publish",
        data={"creation_id": creation_id, "access_token": LONG_TOKEN},
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["id"]

slides = sorted(Path("/var/www/blog.paulbreit.com/carousel-output/2026-05-02").glob("slide-*.png"))
caption = open("/home/marketer/workspace/carousel-output/2026-05-02/caption.txt").read()

container_ids = [create_image_container(f"{PUBLIC_BASE}/{s.name}") for s in slides]
time.sleep(8)  # give Meta time to process each container
carousel_id = create_carousel(container_ids, caption)
time.sleep(5)
post_id = publish(carousel_id)
print(f"Published: https://www.instagram.com/p/{post_id}")

Wiring up the whole cycle

Every stage – idea generation, copy, design, publishing – is run by a single master script that the Claude agent kicks off on cron. The pseudocode:

1. In the morning: generate 3 Reel ideas + 3 carousel ideas → Telegram
2. Wait 30 minutes for the expert's reply
3. If they replied "C2": run the slide-copy prompt for idea 2 → Telegram
4. Wait 30 minutes for "ok"
5. If "ok" received: assemble HTML, render PNGs to the carousel folder
6. Copy the carousel folder to /var/www for public access
7. Through the Meta API: upload containers, create CAROUSEL, publish
8. Send the link to the published post to Telegram
9. Log everything

If the expert doesn't reply at any step, the agent pauses and writes "waiting for a reply." If the expert says "fix X," the agent rewrites and asks for approval again.

Section 10Extending to Threads, Facebook, LinkedIn, Pinterest

Once you've built the agent for Instagram, extending to other platforms takes about an hour each. Same logic: swap the publish function for each platform's. Which platforms are even worth an expert's energy in 2026 is covered in the guide on your first thousand followers across 4 platforms.

Threads

Since late 2025 Threads has an official API. The setup is similar to Instagram: Meta App + Threads product + access token. The publishing method: POST /me/threads with media_type=CAROUSEL and an array of children. Docs: developers.facebook.com/docs/threads.

Limit: a Threads carousel maxes out at 10 items and a caption up to 500 characters.

Facebook

Facebook publishing runs through the same Meta Graph API you already set up for Instagram. Post to your Page with POST /{page-id}/photos for each image (set published=false), then attach them to a single feed post via attached_media. Same token, same app – almost no extra work.

LinkedIn

LinkedIn has the Marketing Developer Platform API. To post a multi-image update: register an app, get a token via OAuth, then use the /ugcPosts (or newer /posts) endpoint with multiple image assets. Docs: learn.microsoft.com/linkedin/marketing.

Limit: LinkedIn doesn't show a swipeable "carousel" the way Instagram does unless you upload a PDF document post – a multi-image post shows as a grid. For document carousels, use the document-share endpoint with your slides exported as a single PDF.

Pinterest

Through the Pinterest API (you need a Business account). The method is POST /pins, one pin per image. Pinterest has no native carousel, but you can create a board and publish a series of pins to it as a set.

YouTube Shorts

YouTube doesn't support carousels as a format. If you want to export there, build a short slideshow from the 7 PNGs (5 seconds per slide) with ffmpeg and post it as a Short. You get a 35-second video carousel.

ffmpeg -framerate 0.2 -pattern_type glob -i 'slide-*.png' \
  -c:v libx264 -pix_fmt yuv420p -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2" \
  output.mp4

Through scheduling services

If you'd rather not write API integrations for every platform, use Buffer, Hootsuite or Later. They take an RSS feed or a manual upload and publish to the right networks on a schedule for you.

Downsides: paid (~$15–30/mo), and some features (trending audio, true carousels on certain networks) may be unavailable or work poorly.

Section 11Cron, monitoring and what to do when it breaks

Automation without monitoring is a time bomb. Within a month something breaks: Meta updates the API, Anthropic changes auth, an image fails moderation. You need to know about it before your followers notice a missed post.

Where the schedule lives

On the VPS – the system crontab. It runs through a wrapper, run-task.sh, which:

• Runs Claude Code in non-interactive mode
• Passes the prompt from a specific file
• Logs stdout/stderr to ~/workspace/cron-logs/{task}_{date}.log
• Deletes logs older than 7 days (so they don't fill the disk)

# crontab -e
# Morning ideas – 8:00 AM US Eastern (UTC-5 = 13:00 UTC)
0 13 * * * /home/marketer/workspace/cron-tasks/run-task.sh ideas-daily \
  /home/marketer/workspace/cron-tasks/prompts/ideas-daily.md

# Refresh the Meta token every 50 days
0 3 1,15 * * /home/marketer/workspace/cron-tasks/run-task.sh refresh-token \
  /home/marketer/workspace/cron-tasks/prompts/refresh-meta-token.md

# Daily health check – verifies tokens are alive and quotas are ok
30 12 * * * /home/marketer/workspace/cron-tasks/run-task.sh health-check \
  /home/marketer/workspace/cron-tasks/prompts/health-check.md

Health check

Once a day the agent checks:

• Whether the Meta token is alive (a request to /me – if 401, the token expired)
• Whether there's enough Anthropic quota (via /usage)
• Whether there's enough disk space (df -h)
• Whether any Claude processes are stuck (ps aux | grep claude)

If something's off, the agent writes to Telegram: "⚠ Problem: Meta token expired, 2 days left." You get to react ahead of time.

Logs and debugging

Every agent run writes logs. The folder structure:

~/workspace/cron-logs/
├── ideas-daily_2026-05-02_13-00.log
├── carousel-publish_2026-05-02_14-00.log
├── health-check_2026-05-02_12-30.log
└── refresh-token_2026-05-01_03-00.log

If something breaks, you immediately know which task and where to look. A single tail -100 on the right log usually shows the cause.

Section 12Upgrades: trending audio, A/B tests, analytics

Once the base system has run for 2–3 weeks, the extensions suggest themselves. Here's what the people who've used the agent longest add.

Trending audio

Carousels with trending audio get +27% reach. The Meta API lets you attach audio to a post through the audio_name parameter. Before publishing, the agent loads the Reels feed page (via playwright + cookies from a real browser session), pulls the top 10 tracks marked "Trending," picks one that fits the mood with Claude, and attaches it to the post.

A subtlety: Meta's Trending API is still in beta and tracking doesn't work on every account. The alternative is a manual pick once a week: you open Reels on your phone, make a list of 5 tracks, drop them in a trending-music.json file, and the agent grabs a random one.

A/B testing covers

The most delicate part of a carousel is the cover (the first slide). It drives the swipe rate – the share of people who move to the second slide. Below 50% means the hook is weak.

The agent can make 2 versions of the cover with different hooks, publish the same carousel on different days with different first slides, then compare reach. After 2–3 months you build your own library of "hook formulas" that work for your specific audience.

Post-publish analytics

24 hours after publishing, the agent hits the Insights API and collects: reach, impressions, saves, shares, swipe-through rate. It logs them to a Notion table. Once a week the agent makes itself a report: what worked, what didn't, which topics drive the most saves.

After 3 months of this, you have the most accurate data on your audience that no SMM agency could give you.

Wiring Notion in for the content plan

Instead of the agent pitching topics itself, you can wire in Notion as the source of ideas. You keep a "Carousel topics" table in Notion with columns: topic, category, status (draft / ready to publish / published). Each morning the agent grabs the first topic with status "ready," publishes it, and updates the status.

This is handy when you already have a strategic content plan for the quarter and you want the agent to execute it rather than pitch its own ideas.

Going further

• DM auto-replies – the agent monitors DMs and automatically answers common questions about your product
• Competitor scraping – once a week the agent goes through 5 competitors in your niche, pulls their top 3 posts of the week, and analyzes what worked for them. A ready-made build of this kind of agent, with a morning roundup and buttons in Telegram, is in the guide on the AI client hunter
• Cross-posting with adaptation – the same topic, but a different format and tone for each network: more polished for LinkedIn, sharper for Threads, more visual for Instagram