Skip to main content
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.
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.

​
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, 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, with the Reloops 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:
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.
GPT-6 Astra running the batch prompt and returning a Download file / Download the ZIP link 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.
1

Create a project

Create a project in Reloops for the campaign.
2

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).
3

Add a Videos folder

Starts empty. Step 3 fills it in, one clip per script id.
Creating a project and adding Scripts and Videos folders in Reloops 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 through the Gemini API. 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.
1

Open Google AI Studio

Go to Google AI Studio and sign in with a Google account.
2

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.
3

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.

​
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:
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, with the Reloops 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:
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.
This only works once your agent can talk to Reloops. Connect the Reloops MCP server to your agent first, see MCP Server and AI Agents and Developer Keys, then come back and paste the instruction below.

​
Do it for all 100

Paste this in, filling in your project name or URL:
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 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

​
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 and point your agent at it. Tried the workflow? Tell us how it went at [email protected].