AI Agents Are Too Good at Marketing Now: How to Build the System Around Them

If you can build a product but still hear crickets when you launch, the interesting question is no longer whether AI can write your ad copy. It is whether you can give an agent everything it needs to research customers, make creative, publish ads, and learn from the results.

That is a much bigger opportunity than generating a few headlines.

A static ad used to require research, copywriting, and a graphic designer. A creator-style video might require a UGC creator, an editor, and a motion graphics designer. Increasingly, agents can coordinate and execute those production steps through software.

But there is a catch: an agent is only as capable as the environment you build around it. Claude Code, GrokBot, or another agent harness does not magically understand your business, have access to your ad account, or know what good creative looks like.

Your job is to build that system. Here is how the pieces fit together, including the workflow we used to turn a brand URL into static ads and an AI avatar video with motion graphics for about $5.

The New Marketing Job Is Building the Environment

I think of this as marketing engineering: turning repeatable marketing work into software workflows, with models making decisions inside clearly defined boundaries.

You are less of a person moving files between applications and more of a conductor. There is a reason the joke about StarCraft players becoming great agent operators resonates. Coordinating a bunch of actions is becoming a real business skill.

This applies beyond ads. Tools such as Mirage Tesseract are bringing automation to long-form editing, including cutting silence and retakes, identifying the active speaker, and choosing when to show a screen. The broader shift is that work previously done by a person clicking around can increasingly be executed by an agent with the right tools.

For marketing, the environment has three essential parts:

• Data: Business information the agent can query to understand what is happening.
• Access: Permission to publish content and make changes in ad platforms.
• Tools: APIs for generating images, producing video, transcribing audio, and doing other production work.

I would add a fourth: creative context. That includes brand rules, examples worth learning from, and a definition of what qualifies as good enough to publish.

The mistake is giving an agent a vague instruction to run your marketing and expecting greatness. The better approach is to identify what a great marketer actually does, then build those jobs into workflows.

Give the Agent a Data Warehouse, Not a Giant API Response

Start with the data problem.

You could ask an agent to pull information directly from Facebook Ads, Google Analytics, your CRM, and your payment processor whenever it needs an answer. But that quickly gets messy.

Large responses fill the context window. The agent may misinterpret the information, build an improvised local database, or introduce duplication errors. Repeated requests also run into platform rate limits.

The more durable architecture is a data pipeline feeding a central warehouse.

Use a pipeline to collect the data

Airbyte is the pipeline option discussed here. Its job is to move data from the systems where it originates into a place where it can be analyzed together.

Those sources might include:

• Facebook Ads and Google Ads.
• Google Analytics.
• HubSpot or another CRM.
• Product analytics, such as PostHog.
• Your payment processor.

Store it in one analytical system

ClickHouse is the warehouse option used in this architecture. The pipeline keeps bringing information in, and the agent queries the warehouse rather than repeatedly pulling the same information from every source.

This is not just cleaner plumbing. It changes what you can ask.

Instead of asking which ad got the cheapest click, you can follow an ad through website activity, CRM records, product behavior, and payments. You can ask which creative brings in revenue and, more importantly, which creative brings in customers with better lifetime value.

That is the real unlock. An ad that generates a cheap lead is not automatically the ad that generates your best customer.

The warehouse gives the agent a cross-business view. It also separates ongoing data collection from analysis, so every new question does not require a fresh burst of requests against an ad platform.

Read From the Warehouse, Write Through the Ad APIs

The next piece is access.

In this setup, the agent reads performance data from the warehouse. It uses the ad platforms’ APIs to take actions, such as:

• Uploading new creative.
• Creating or organizing ads.
• Turning ads off.
• Making campaign changes.

For Facebook, that means setting up access through the Meta Marketing API. The Facebook developer token setup guide provides a walkthrough you can give to your agent to help with the process.

This read/write separation is an architectural choice, not a limitation of the API. The pipeline still needs to collect source data. The point is to keep the agent’s exploratory analysis from hammering the source platforms.

Assume an unconstrained agent can behave like a drunk patron at a restaurant: lots of confidence, very little awareness of the trouble it is causing.

If it decides to fire off a huge number of requests, you can run into rate limits and policy problems. Do not interpret every account problem as proof that agents cannot handle ads. Sometimes the surrounding infrastructure is the problem.

Apply the same principle to Google Ads: centralize the analytical reads, and give the agent controlled access for the actions it needs to perform.

Tools Let Agents Do the Production Work

Data tells the agent what is happening. Access lets it act. Tools let it make things.

The tool layer can include Kai AI for image and video generation, fal for audio and transcription workflows, OpenRouter for language models, and providers such as Apollo or Get Leads for contact data.

You do not need every tool for every workflow. You need the capabilities required for the job you are automating.

A static-ad workflow needs research and image generation. A UGC avatar workflow needs voice generation, video generation, transcription, and editing. An outbound workflow would need a different set of capabilities.

One example Cody described was a Google Ads agent that checks search terms against the landing page they send traffic to. The question is straightforward: does this search imply buying intent for this offer?

His reported example involved auditing 5,000 search terms in roughly 20 seconds. A human can perform that kind of judgment, but not at that speed and volume. The interesting part is not that the agent has invented a new marketing discipline. It is that a useful, labor-intensive task becomes practical at a different scale.

Build the stack yourself or use a bundled platform

You can assemble the pipeline, warehouse, credentials, and generation tools yourself. That gives you control, but you are responsible for connecting and maintaining the pieces.

The alternative demonstrated was a bundled platform, Graphed, which brings together data, platform access, and tools. The team-based part matters too: several people can use their own agents against shared infrastructure instead of each maintaining a separate setup.

The demo used an installed CLI package that gives the agent instructions for using the platform. The principle is portable: the agent needs both access to capabilities and knowledge of how to use them.

Build a Swipe Warehouse, Not Just a Swipe File

Infrastructure alone does not give you taste.

You can buy the tools, connect the data, and still produce boring creative. That is why I would build a swipe warehouse alongside the performance warehouse.

A traditional swipe file is a small collection of ads or ideas you like. An AI-assisted workflow can use a much larger, continuously updated library of creative references.

That library should give your agent examples of the kinds of work you consider excellent: compelling hooks, interesting visual treatments, clear offers, and formats that fit your audience.

Tools such as Sublime or Cosmos can help organize inspiration. The important part is not the application. It is making the references available to the workflow and continuing to add useful examples.

I would also give the review process a grounding in advertising fundamentals, drawing on resources such as David Ogilvy’s work and interviews with strong creative practitioners. Combine those principles with your own curated examples.

Your reference library captures taste. Your performance data tests whether that taste works in the market. You want both.

Workflow One: Turn a Brand URL Into Five Static Ads

The static-ad demonstration started with a simple input: a brand URL.

With the static-ad skill already installed, the command was /static-ads, followed by the business website. That command is not a built-in feature every agent automatically has. It invokes a configured workflow.

The skill then performs the work that would normally sit between a marketing brief and a finished design:

1. Inspect the website. Extract the brand’s visual language, including fonts and colors.
2. Look for existing ads. Check the brand’s presence in the Meta Ad Library, if available.
3. Research the customer. Look for conversations on Reddit and other social platforms about relevant pain points and desired outcomes.
4. Propose five concepts. Turn the research into distinct creative angles.
5. Generate the images. Produce static ads based on those concepts and the brand context.
6. Prepare for publishing. Use the connected ad account when the creative is approved.

We ran this across Idea Browser, Late Checkout, Aimé Leon Dore, Cursor, David protein bars, and Robinhood. The useful test was whether the workflow could adapt to different products and brand identities.

The concepts came from customer problems

For Idea Browser, the proposed angles focused on choosing a startup idea with more confidence: avoiding months spent on a weak concept, finding evidence of demand, and moving beyond generic AI-generated suggestions.

For Late Checkout, the concepts explored finding product opportunities in support tickets and giving companies the ability to operate a product lab. Cursor’s concepts included understanding code that had never been properly documented.

The Aimé Leon Dore angles were different again: retail versus resale, long-term wear, gifting, and the experience around the brand.

These were generated concepts, not proven winners. That distinction matters. Research gives you hypotheses worth testing, not a guarantee that the market will respond.

Use explicit brand rules when you have them

Extracting a style guide from a website is a useful starting point. But if you already know your fonts, colors, and visual rules, give the agent that information directly in a Markdown file.

You can revise the generated ads, supply stronger references, and adjust the skill. You can also swap the image model when another endpoint gives you better results. The workflow does not have to be permanently tied to one generator.

Once the ads are ready, the connected agent can upload them into an ad account and a new ad set. In the demonstration, that upload was stopped before continuing. Generating the creative and authorizing its release should be separate decisions.

Workflow Two: Make an AI UGC Avatar Ad for About $5

The next step was to reuse the research and concepts from the static ads to create a creator-style video.

The request was essentially: use /ugc to write a script based on the work above, then make the ad.

The important part is what happens inside that skill. Sending a script straight to a video model and hoping for the best can produce inconsistent voices, garbled words, and an avatar you did not intend to create.

The demonstrated workflow reduces those degrees of freedom.

1. Generate the audio first

Start with the approved script and create an MP3 using a voice-generation workflow through fal.

Now you have a specific performance rather than asking the video model to invent the voice and delivery at the same time as everything else.

2. Send three inputs to the video model

The Seedance generation receives:

• The exact script.
• The MP3 containing the intended read.
• A reference image defining the avatar’s appearance.

Think of this as a walled garden. You are telling the model what to say, how it should sound, and what the person should look like.

The image reference also helps reduce the overly polished, plasticky look that can come from unconstrained generation. The demo used a realistic photographic starting point rather than asking the model to invent the entire visual style.

Product reference images can be included as well. For example, you can ask for an avatar to hold a product and provide the relevant image instead of relying only on a written description.

3. Render a lower-cost first version

The workflow generated a 480p first version, then upscaled it and applied blur using FFmpeg.

The goal was cost control. Generating the initial video at a higher resolution was more expensive in the configuration discussed. The lower-resolution route provided a cheaper starting point for the rest of the process.

4. Check the spoken words and repair mistakes

The skill creates a word-level transcription and compares it with the intended script.

If a product name is mispronounced, the system can identify the relevant timestamps and replace that segment. The example discussed was a bad pronunciation of Calendly.

This is a valuable distinction: you do not necessarily need to regenerate an entire video because one word went wrong. You can structure the workflow to locate and repair the error.

5. Add captions and motion graphics

The next request used Tesseract to add motion graphics. The existing word timings also support caption placement.

The result included an avatar read, visual overlays, and an on-screen call to action. But the first pass still had alignment issues. Producing a plausible video is not the same thing as producing a finished ad.

What the cost actually means

The projected generation cost shown was about $4.75, with a small additional cost for motion graphics. The practical estimate was roughly $5 per ad.

At that rate, 10 variations would be about $50 and 100 would be about $500 in generation costs. The comparison discussed was roughly $300 to $500 or more for a human creator, editing, and motion graphics on a single ad.

Those are examples from this setup, not universal prices. They also do not include media spend or the time needed to build and supervise the workflow.

The same production sequence can run in a cloud-hosted agent environment rather than on a laptop. That is how it becomes a repeatable batch process instead of a one-off experiment.

Keep Human Creators in the Workflow

None of this requires replacing every creator with an avatar.

You can use the same research and scripting process, then send the brief to a human through a creator network such as Tribe or SideShift.

The agent becomes the coordination layer:

1. Prepare a script and creative direction.
2. Send the brief to creators through the platform.
3. Receive the recorded footage.
4. Run that footage through the captioning and motion graphics workflow.
5. Route the finished ad for approval.

One example discussed involved paying around $40 per creator video. Other arrangements can include per-video compensation and bonuses connected to spend.

The creator can adapt the script rather than delivering it mechanically. You keep the human contribution where it adds value while automating the administrative and production work around it.

And even with an entirely synthetic video, you can still require a human approval gate before anything goes live. Autonomy is a design choice, not a requirement.

Add a Creative Director Step Before Publishing

The first thing I would add to this system is a creative review stage.

Do not show me every rough generation. Check it first. Find the obvious mistakes, fix them, and only escalate work that meets the standard.

This is similar to reviewing software before shipping it. A vision-capable model can inspect the output, identify problems, and send specific changes back through the workflow.

The loop looks like this:

1. Generate the creative.
2. Evaluate it against the brief and quality rules.
3. Identify the changes required.
4. Revise the output.
5. Repeat until it passes, then send it to the human approval gate.

Frame-by-frame motion graphics review was an improvement discussed for the workflow, not something the first result had already perfected.

A related loop was already being used for static creative in regulated financial markets. The reviewer checks the image against rules about what the company can say, cannot say, and cannot promise, then requests revisions. Cody described typically getting through that process in two or three rounds.

The lesson is to think in jobs to be done, not imaginary employees. You do not need one all-powerful agent pretending to be a marketing department. You need specific, reliable steps connected to live information.

A score such as eight out of ten is only useful if you have defined what the score means. Brand consistency, legibility, accurate claims, correct pronunciation, and aligned overlays are much more actionable than asking whether an ad “looks good.”

Creative Velocity Only Matters If You Close the Feedback Loop

Once production becomes cheaper, you can test more distinct ideas.

That does not mean blindly uploading hundreds of ads. The right volume depends on your budget, cost per lead, and ability to give creative a meaningful test.

The argument for creative velocity is that Facebook’s delivery system can match different ads to different people. Some variations will find a small pocket of demand without becoming durable, high-spend winners.

One software example involved an ad getting two demos at around $50 each, compared with a roughly $150 average, before the platform stopped spending on it. That is a useful result, but not proof that the ad can scale indefinitely.

Likewise, Cody reported cases where an AI avatar outperformed a human delivering the same script. That is a reason to test both, not a reason to assume avatars always win.

The most interesting part comes after publication.

A generation request is structured data. You can store the prompt or JSON payload that produced an ad, connect it to the published ad’s identity, and join that record to performance data.

Now you have a record of what you made and what happened afterward. Across many ads, the system can compare creative decisions with conversions, revenue, and customer quality.

The loop is research, generate, review, publish, measure, and learn. If you stop at generation, you have a content machine. If you connect the outcome data, you have the beginnings of a marketing system.

Start With One Complete Workflow

The practical starting point is not to automate your entire company.

Choose one product and one workflow. Give the agent the right data, connect the tools, document the brand, and define the approval criteria. Then run a small batch all the way through production and measurement.

The same environment-based thinking can extend to outbound prospecting or SEO. But those need their own workflows. A total addressable market map, contact enrichment, and outreach sequence are not automatically solved because your agent can make an image ad.

What becomes valuable over time is the shared repository: the skills that work, the references your team trusts, the rules that prevent mistakes, and the performance history that improves the next decision.

The models will keep changing. Building the system around them is the durable skill.

The shared marketing skills provide a starting point for the research, static-ad, and UGC workflows described here.