> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reloops.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Automating 100+ UGC Videos a Week

> A start-to-finish workflow for scripting and generating 100 UGC videos a week using GPT-6 Astra, an AI video generator, and Reloops.

Hiring creators to make UGC is slow and expensive: a brief per creator, days per batch, another round trip for every revision. It works for four videos a month, not forty.

GPT-6 Astra changes that. Its context window now holds an entire campaign in one prompt, every past transcript, caption, and metric, so it writes scripts from your actual data instead of generic ad copy. That capability is the new part, not the model itself: any model with a big enough context window does the same job. An agent turns those scripts into videos end to end.

This post is the experiment: the prompts, the tools, and where each hands off to the next. Reloops is the storage layer in the middle.

<Warning>
  This is an experimental workflow we ran ourselves, not a supported or guaranteed pipeline. Script quality, hook performance, and video fidelity all depend heavily on which models you plug in — swap the script model or the video generator and your results won't match this post's screenshots.
</Warning>

## Tldr

The whole workflow in three steps:

1. Load your campaign history into GPT-6 Astra, then have it write 100 UGC scripts across a spread of hook structures.
2. Create a Reloops project with Scripts and Videos folders, then store the scripts as one asset per script using MCP.
3. Run an agent loop that turns each script into a video and uploads each one into the Videos folder, named to match its script.

Generate on Monday and by Tuesday you have a folder of finished videos.

## Setup

What you need before Step 1:

* A large-context model. We suggest GPT-6 Astra, since that's what we used and tuned the prompts below against, but any model that fits your full campaign history in one prompt works — swapping it changes voice and quality, not whether the workflow runs.
* An AI video generator with an API: Higgsfield, HeyGen, Arcads, Veo, and others. These vary in output quality and realism more than LLMs vary from each other, so this is the choice that will move your results the most.
* [Reloops](https://www.reloops.app/), for storing the scripts and videos.
* Somewhere to run the agent loop that connects them: a script, a cron job, or an MCP-capable agent runner like the [Codex CLI](https://developers.openai.com/codex/cli), with the [Reloops MCP server](/developers/mcp-server) connected to it.

## Step 1 - Generate the scripts

Two prompts do the work here: one to load your campaign context, one to generate the batch. Run them in order, in the same conversation, so the second prompt can see the first. Treat both as a starting point, not a script to paste verbatim — the structure (context first, then the batch ask, with a fixed output format) is what matters, so rewrite them in your own words if that gets better results out of your model.

### Load your campaign context

This is the step everyone skips, and it's the step that makes everything else work. Without it you're asking a stranger for advice about a business it's never seen.

**Paste this into GPT-6 Astra** before anything else so the next person (or the next prompt) doesn't have to reconstruct it from memory:

```
"here is everything you need to know about my UGC program before we start any analysis.

BUSINESS BASICS:
app name: [your app name]
category: [health, education, finance, social, etc.]
one-sentence value prop: [what the app does in 15 words or less]

CAMPAIGN HISTORY:
total creators managed: [X]
total videos produced: [X]
platforms active on: [TikTok, Instagram Reels, YouTube Shorts]
biggest campaign win: [one sentence]
biggest campaign failure: [one sentence, be honest]

CURRENT CAMPAIGN:
campaign name: [X]
active creators: [X]
brief template: [paste your current brief, or link the Reloops doc]
compensation model: [flat fee / retainer / bonus]

HOW I WANT YOU TO WORK:
always prioritize actionable output over analysis.
rate every recommendation by impact (high/medium/low) and time to implement.
output data in table format when comparing anything.
never invent a number. if you can't verify it, say so.
when analyzing hooks, cluster by structure, not by topic."
```

Once this is loaded, every prompt below gets sharper. Astra stops answering a generic marketing question and starts answering yours.

### Generate the batch

With the context loaded, this is the prompt that produces the scripts. It asks for a spread of hook structures instead of 100 rewrites of one idea, and it forces a format the next tool can read without cleanup.

```
"generate 100 short-form UGC video scripts for the campaign above.

RULES:
- each script is 8 to 10 seconds read aloud at a natural pace, short enough for a single video generation.
- spread them across at least 8 distinct hook structures (question, bold claim, before/after, callout, myth-bust, POV, list, demo). do not write 100 variations of one hook.
- every script must be grounded in the campaign history above. do not invent features, numbers, or customer quotes.
- if a line needs a number or claim you cannot verify from the context, write [VERIFY] in its place.
- match the voice of the best-performing past videos, not a generic ad voice.

OUTPUT FORMAT (one file per script):

id: 001
model: [name and version of the model generating this script]
hook_structure: question
hook: [first line, on screen and spoken]
on_screen_text: [overlay for the hook, max 8 words]
body: [1 short sentence]
cta: [last line]
shot_notes: [setting, framing, any prop, one line]

write each script to its own file named <id>-<hook_structure>.md, for example 001-question.md. once all 100 files exist, package them into a single zip and give me a download link.

return only the zip. no commentary before or after."
```

<img src="https://mintcdn.com/reloops/-a_zLZgxiMGUEgkH/images/chatgpt-generate-batch-zip.png?fit=max&auto=format&n=-a_zLZgxiMGUEgkH&q=85&s=262ae904a5b72b07a29815921beab3fc" alt="GPT-6 Astra running the batch prompt and returning a Download file / Download the ZIP link" width="1857" height="988" data-path="images/chatgpt-generate-batch-zip.png" />

Hook variety, groundedness, and writing voice are a direct function of which model runs this prompt — GPT-6 Astra is the model we used, not a requirement. The `model` field on each script exists so you can tell which model wrote it later, which matters if you swap models mid-campaign or need to compare a batch's performance against the model that generated it.

## Step 2 - Store the scripts where the agent can read them

Astra already handed you a zip of 100 script files, one per id, because the prompt in Step 1 asked for exactly that. Unzip it and you have precisely the structure you need: one file per script, each with its own id, so an agent can walk the list, generate a video for each, and write the result back next to the script it came from.

<Steps>
  <Step title="Create a project">
    Create a project in Reloops for the campaign.
  </Step>

  <Step title="Add a Scripts folder">
    Unzip Astra's file and upload the 100 files here, one asset per script, each named by its id (001-question, 002-bold-claim, and so on).
  </Step>

  <Step title="Add a Videos folder">
    Starts empty. Step 3 fills it in, one clip per script id.
  </Step>
</Steps>

<img src="https://mintcdn.com/reloops/-a_zLZgxiMGUEgkH/images/create-project-folder.gif?s=56051fbddd62f719df55f59e864facd2" alt="Creating a project and adding Scripts and Videos folders in Reloops" width="960" height="540" data-path="images/create-project-folder.gif" />

<video src="https://mintcdn.com/reloops/-a_zLZgxiMGUEgkH/videos/workspace-after-upload-100-scripts.mp4?fit=max&auto=format&n=-a_zLZgxiMGUEgkH&q=85&s=5a520192651001f7a297fad99a5ccd60" controls data-path="videos/workspace-after-upload-100-scripts.mp4" />

On upload, Reloops reads each script and tags it: the hook structure, the format, the subject, plus a one-line summary.

Any store with an API can do this job. The requirement is structure and an id per script, not the specific tool.

## Step 3 - Generate the videos and upload them to Reloops

Turning a script into a video is three small pieces: a video generator with an API, one Veo prompt per script, and a loop that runs it 100 times and uploads the result.

### Get a video generator

You need an AI video tool with an API. We used the [Google Veo 3.1 video generation model](https://ai.google.dev/gemini-api/docs/video) through the [Gemini API](https://ai.google.dev/gemini-api/docs). Any generator with an API works the same way: Higgsfield, HeyGen, and Arcads all take a script, a voice, and a scene. The rest of this section is written against Veo specifically, since that's what we used — swapping generators means adapting the API calls below, not just the prompt.

<Steps>
  <Step title="Open Google AI Studio">
    Go to [Google AI Studio](https://aistudio.google.com/) and sign in with a Google account.
  </Step>

  <Step title="Create an API key">
    Click **Get API key**, then **Create API key**. Copy it somewhere safe, you'll hand it to your agent in the next section.
  </Step>

  <Step title="Turn on billing">
    Veo is not on the free tier. Attach a billing account to the project before you generate anything, or the API calls will fail.
  </Step>
</Steps>

### One script, one prompt, one video

Every field from the Step 1 format maps to a Veo input:

* hook, body, and cta become the spoken lines
* on\_screen\_text becomes the caption overlay
* shot\_notes becomes the scene

Assembled, script 001 becomes one Veo prompt:

```
Vertical 9:16 selfie video. Talking head at a kitchen counter,
phone in hand, casual morning light. She speaks to camera:
"What actually happens the first day you forget your streak?
Tally keeps it and asks what got in the way. Open Tally and start today."
Caption on screen: "the day you forget"
```

Veo returns a 10-second clip. That is 001's video.

### Hand the key to your agent

The loop is one instruction you hand an agent (we used the [Codex CLI](https://developers.openai.com/codex/cli), with the [Reloops MCP server](/developers/mcp-server) connected to it and the Veo API key from the step above set as an environment variable). "Set as an environment variable" means one command, run in the same terminal you'll launch the agent from:

```bash theme={null}
export GEMINI_API_KEY="paste_the_key_you_copied_above"
```

Run `codex` from that same terminal afterward. The key only needs to exist for that terminal session, so if you close it and open a new one, export it again before starting the agent.

<Note>
  This only works once your agent can talk to Reloops. Connect the Reloops MCP server to your agent first, see [MCP Server](/developers/mcp-server) and [AI Agents and Developer Keys](/developers/ai-agents-and-developer-keys), then come back and paste the instruction below.
</Note>

### Do it for all 100

Paste this in, filling in your project name or URL:

```
Process the scripts in the Scripts folder of this Reloops project:

[PROJECT NAME OR URL]

Video model: Google Veo 3.1, via the Gemini API (swap this line and the credential
below for your own generator and its API if you're not using Veo).

Goal: generate and upload videos for the first [N] scripts, or all scripts if N is not specified.

For each script file:

1. Read the fields:
   - hook
   - body
   - cta
   - on_screen_text
   - shot_notes

2. Create a prompt for the video model specified above, using:
   - shot_notes as the visual scene direction
   - hook + body + cta as the exact spoken dialogue
   - on_screen_text as the exact on-screen caption

3. Generate an MP4 using the video model specified above, with the configured
   `GEMINI_API_KEY` (or your generator's equivalent credential).
   Use vertical 9:16 format and short-form UGC social-video styling.

4. Wait for the long-running generation operation to finish and download the returned MP4.

5. Upload the MP4 to the Videos folder in the same Reloops project.
   Preserve the original filename, changing only the extension:
   `007-list.md` → `007-list.mp4`

Execution requirements:

- Use the Reloops MCP tools to read scripts and upload videos.
- Use the video model specified above directly for video generation.
- Process multiple files concurrently to reduce total runtime, but respect API and Reloops rate limits. Start with a concurrency of 3 and reduce it automatically if quota or rate-limit errors occur.
- Do not ask for confirmation between files.
- Automatically retry transient API, download, and upload failures up to 3 times with exponential backoff.
- If a file fails after all retries, continue processing the remaining files and report the failure at the end.
- Skip a video if the correctly named MP4 already exists in the Videos folder, unless regeneration is explicitly requested.
- Maintain a progress log containing each filename, generation status, upload status, asset ID, and error message if applicable.
- Verify that every successful upload has:
  - the expected filename
  - `video/mp4` content type
  - a nonzero file size
  - the correct Videos folder ID
- At completion, report:
  - total files discovered
  - successfully generated
  - successfully uploaded
  - skipped files
  - failed files and reasons
  - uploaded asset IDs
  - any remaining quota or rate-limit issues

Begin immediately and run the complete batch without requesting per-file approval.
```

Set `[N]` to 10 the first time, not 100. That's what we did: we ran the loop against ten scripts first, caught a prompt-wording issue on the third one, and by the time we'd tuned it and re-run, we'd burned about \$25 generating six usable videos. Video generation isn't cheap when you're iterating on the prompt, and a bad run of 100 costs a lot more to discover than a bad run of 10 does. Once the first ten look right, drop `[N]` and paste the instruction again for the rest.

The one deliberate constraint worth calling out: bounded concurrency. Firing off all 100 generations at once sounds faster, but it walks straight into Veo's quota limits and most of the batch fails together. Three concurrent jobs with automatic backoff on quota errors is slower per-file but finishes the batch faster in practice, because it isn't spending most of its time retrying a wall of 429s.

The retries, skip-existing check, and verification step also make the instruction safe to run more than once: if it dies partway through (quota exhausted, a bad connection), pasting the same instruction again picks up where it left off instead of regenerating and re-uploading everything from 001.

It reads from Scripts and writes to Videos through the Reloops MCP server, so there is no manual upload step, and the closing report tells you exactly which files (if any) still need a rerun.

![The batch loop running: each script read from Reloops, a Veo prompt built, the clip generated and uploaded to the Videos folder](https://uploads.linear.app/918fc35d-479a-43f8-93f5-da6404a21b57/ae69c8e8-442e-42b9-9c32-82a5c767541e/4a65e9ea-d0c2-4dd6-880f-83f654e9226f?signature=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwYXRoIjoiLzkxOGZjMzVkLTQ3OWEtNDNmOC05M2Y1LWRhNjQwNGEyMWI1Ny9hZTY5YzhlOC00NDJlLTQyYjktOWMzMi04MmE1Yzc2NzU0MWUvNGE2NWU5ZWEtZDBjMi00ZGQ2LTg4MGYtODNmNjU0ZTkyMjZmIiwiaWF0IjoxNzg5MDgxMDIzLCJleHAiOjE3ODkwODEzMjN9.Z6GOrJtu_SCcHcEbEPSHI224ajguJMHtsDH1FigBiWQ)

When the loop finishes, the Videos folder mirrors Scripts, one clip per script id, ready to watch.

![The Videos folder in Reloops after the loop finishes, one clip per script from 001 to 010](https://uploads.linear.app/918fc35d-479a-43f8-93f5-da6404a21b57/09d75046-bdc5-435e-85ca-5bda1e393d79/1de05b59-e153-4e35-b991-aeb97438e7dd?signature=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwYXRoIjoiLzkxOGZjMzVkLTQ3OWEtNDNmOC05M2Y1LWRhNjQwNGEyMWI1Ny8wOWQ3NTA0Ni1iZGM1LTQzNWUtODVjYS01YmRhMWUzOTNkNzkvMWRlMDViNTktZTE1My00ZTM1LWI5OTEtYWViOTc0MzhlN2RkIiwiaWF0IjoxNzg5MDc4MTMwLCJleHAiOjE3ODkwNzg0MzB9.wVggF1-5wTPd6_jjIDb0HspCgFd-ut1oteL5Yfe70MA)

## Run it yourself

The two prompts in Step 1 are copy-paste ready. Load your campaign context, run the batch, and you have your scripts in one pass. The generation loop is some wiring against whichever video tool you pick.

The one piece you do not have to build is the storage layer. That is what Reloops does: one place for the batch to land, searchable and tagged the moment each script or video is uploaded. Start with [Reloops](https://www.reloops.app/) and [point your agent](/developers/mcp-server) at it.

Tried the workflow? Tell us how it went at [support@reloops.app](mailto:support@reloops.app).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.