AI Agent Marketing Automation: Connect Your Creative Review to Your Pipeline

Most automated ad pipelines already have two stages wired together: something that generates the creative (an agent, a prompt template, a generation tool) and something that ships it (a publish call, a queue, an approval list). The review step goes between those two— right after generation produces a variant, and before that variant is eligible to move to the publish or queue step.

That placement matters more than it sounds. Bolt the review onto the generation step itself (asking the same model that wrote the ad whether the ad is good) and you get an optimistic self-assessment, because the model that produced the output has no reason to contradict itself. Bolt it onto the end, after the ad is already queued or published, and you’ve caught the problem too late to matter. The wire needs a dedicated hop in the middle: generate → review → publish, with the review step making an independent call and returning a verdict your pipeline can branch on.

Concretely, this is a single additional call inserted into a pipeline you already have. You don’t need to rebuild the generation step or the publish step — you need to route the output of one into Spendict’s assess_ad_creative tool, and route the verdict into whatever branching logic your queue or publish step already supports.

Which path you use depends on what your generation step already runs on. All three hit the same scoring engine and return the same verdict shape, so switching later doesn’t change anything downstream.

MCP — for agent-native pipelines.If your generation step runs inside Claude, Cursor, or Codex, the review step is a native tool call rather than a separate integration. Spendict runs a remote MCP server over Streamable HTTP with OAuth — no API key to create or paste:

https://www.spendict.com/api/mcp

Connect once and the agent that generated the variant can call assess_ad_creative directly, in the same session, without leaving the agent environment or handling any HTTP plumbing.

REST — for custom backends. If your pipeline is a custom service or script rather than a chat-based agent, wire the review step in as a plain HTTP call with bearer-key authentication (create a key in the dashboard):

POST https://www.spendict.com/api/v1/assess
Authorization: Bearer spd_live_YOUR_KEY
Content-Type: application/json

{
  "ad_copy": { "primary_text": "Your generated variant here" },
  "platform": "meta",
  "product_context": "what you sell, the offer",
  "target_audience": "DTC skincare buyers, 25-40F"
}

Drop this call right after your generation function returns and before whatever function hands the ad off to your publish or queue step.

n8n — for no-code pipelines.If your automation is already built as an n8n flow, add an HTTP Request node calling the same REST endpoint between your generation node and your publish node, then route on the response. There’s a ready-made version of exactly this pattern — the ad-factory template on the n8n gallery — which you can import and adapt instead of wiring the node from scratch. More detail on the n8n ads automation page.

The contract on the wire is simple in both directions, which is what makes it easy to insert into an existing pipeline without redesigning anything around it.

In:one generated variant, plus the context your review needs to judge it — the ad copy, the target platform, and a short description of the product and audience. No history, no conversation state. Each call is independent, so you can fire N variants through the wire concurrently and score all of them in roughly the time it takes to score one.

Out: a verdict — run, fix_first, or kill— plus the dimension scores behind it and the single predicted failure mode. Your pipeline doesn’t need to parse free text or interpret tone; it reads one field and branches on it.

• ✓run→ approve — the variant moves on to your existing publish or queue step unchanged.
• ✓fix_first→ revise — the variant and the named failure mode route back to your generation step for a targeted rewrite, then go through the wire again.
• ✓kill→ reject — the variant is discarded and your pipeline moves to the next one, or requests a fresh batch from generation.

Because the verdict is computed server-side from fixed rules rather than proposed by the model, the same variant sent through the wire twice comes back with the same verdict. That consistency is what makes it safe to let the pipeline branch automatically instead of routing every borderline case to a person.

An unattended pipeline needs to handle the review step failing gracefully, not just succeeding. Two things are worth building in on your side of the wire.

Quota runs before inference.If the key making the call has no calls left, Spendict returns a structured error immediately — the request never triggers a model call in the background. That means a maxed-out key fails fast and cheap; your pipeline isn’t left waiting on a call that was always going to fail, and it isn’t billed for one either.

Failed calls are refunded. If a call to assess_ad_creativeerrors out for any reason on Spendict’s side, the call is refunded automatically. You don’t need to build reconciliation logic to track which failed calls should count against your quota — only successful assessments consume it.

What your pipeline should do. On a structured {error, message}response, the safest default for an automated wire is a clean stop rather than a retry loop: log the error, halt the batch, and surface it, instead of hammering the endpoint or — worse — falling back to publishing the variant unreviewed. A review step that fails open defeats the point of wiring it in at all.

The fastest way to see this working is to pick the one integration path that matches your existing pipeline — MCP if your generation step is agent-native, REST if it’s a custom backend, n8n if it’s already a no-code flow — and insert a single call between your current generate and publish steps. You don’t need to touch anything else in the pipeline to start seeing verdicts.

For the broader pattern this fits into, see the AI agent ad workflows pillar guide and the practical guide to AI marketing automation. The full API and MCP reference is in the docs.