Every campaign starts the same way: someone opens a blank doc and tries to remember what they already know. What did the competitor launch last month? What audience segment performed in Q1? What were the three things the client said mattered most? The briefing phase — the information-gathering before strategy starts — takes longer than it should, eats into the thinking time, and often ends with gaps nobody noticed until the campaign is already running. At Choco Media, we’ve spent the last year building an AI marketing briefing system that does most of this gathering automatically. What follows is how it works, why we built it, and how you can build something similar for your own team.
This post is for marketing teams and agencies that run recurring campaigns — whether that’s monthly paid media cycles, content calendar builds, or quarterly brand pushes. If your briefing process currently looks like “whoever knows the most talks first”, this is for you. You don’t need to be technical to follow it. Most of what we describe here runs on tools like n8n, Make, or Zapier with a language model wired in. The hard part is the design, not the code.
We call this a briefing agent, but it’s really an automated intake pipeline with an AI reasoning layer at the end. It doesn’t write the strategy. It collects the inputs so a human can write a better strategy faster.
Why Briefing Fails Before Strategy Begins
The problem with most campaign briefs isn’t the template. Templates exist. The problem is that filling them in requires pulling information from five different places — a CRM, a previous campaign report, a Slack thread from six weeks ago, a client email, and someone’s memory. That work falls on whoever is running the kickoff, and it happens under time pressure, which means it happens incompletely.
In client work, we’ve found that a significant portion of revision rounds in campaigns trace back to briefing gaps rather than execution errors. The creative was off because the audience wasn’t specified precisely. The landing page underperformed because nobody checked what the competitor was doing. The messaging felt stale because nobody pulled the last three months of customer feedback before writing the angle.
- Briefing gaps that matter most: unclear target audience segment, missing competitor context, no reference to previous campaign learnings, vague offer definition
- Where those gaps come from: time pressure, distributed information, no single source of truth, manual processes that don’t scale
- What an automated briefing agent addresses: it runs the same information-gathering steps every time, doesn’t forget, and delivers a structured summary before the strategy conversation begins
The goal isn’t to replace the strategist. It’s to make sure the strategist walks into the room with all the relevant context already surfaced.
What the Briefing Agent Actually Pulls
Before designing the automation, we mapped every piece of information that genuinely affects campaign decisions. Not everything needs to be gathered every time — some fields are campaign-type-specific — but the core set is consistent.
Competitor signals
What have the top two or three competitors published or promoted in the last 30 days? This includes new landing pages, active ad creatives (via Meta Ad Library or SimilarWeb), blog posts, and any product announcements. We pull this via a scheduled web scraper and route it into a summary prompt.
Audience and segment data
Which audience segments are currently active in paid channels, and how have they performed in the most recent campaign period? This comes from a CRM export or a direct API pull from the ad platform. The agent formats it as a table: segment, reach, conversion rate, cost per result.
Previous campaign learnings
What were the key findings from the last campaign that ran against the same objective? We store these as structured notes in Notion after each campaign review. The agent retrieves the relevant entry by matching campaign type and objective.
Client or stakeholder inputs
What has the client communicated in the last two weeks that is relevant to this campaign? The agent scans a designated Slack channel or email label for anything tagged with the campaign name and extracts key points.
- Competitor activity (Meta Ad Library, homepage, recent blog posts)
- Audience performance data (last 30–90 days by segment)
- Previous campaign learnings (structured notes from post-campaign review)
- Client signals (Slack, email, recent calls — key points extracted)
- Offer and product context (current pricing, active promotions, inventory signals if relevant)
- Seasonal and timing context (what’s happening in the market this month)
“The brief that produces the best strategy isn’t the longest — it’s the one with the fewest gaps. An agent can’t make the decisions, but it can make sure the decision-maker is working from complete information.”
The Architecture: Three Layers
The agent runs on three distinct layers. Understanding the separation makes it easier to build and easier to debug when something goes wrong.
Layer 1: Data collection
This is the automation backbone — the part that actually goes and fetches things. Each data source has a dedicated module: a web scraper for competitor pages, an API connector for ad platforms, a database query for CRM data, a filter for email or Slack. These run on a trigger (campaign kickoff event or scheduled time) and deposit raw data into a central staging area — a Notion database, a Google Sheet, or a simple JSON file depending on your stack.
Layer 2: AI summarisation and structuring
Once the raw data is collected, a language model runs over each section and produces a structured summary. The prompt for each section is specific: for competitor data, it produces a three-bullet summary of what the competitor appears to be emphasising. For audience data, it flags the highest-performing segment and the one with the most room to improve. For previous learnings, it extracts the top two actionable findings. Each section is a separate prompt — combining them into one prompt degrades output quality.
Layer 3: Brief assembly and delivery
The summaries are assembled into a brief template and delivered to the strategy lead. Delivery can be a Notion page, a Slack message with a link, or a document dropped into the campaign folder. The brief includes a “confidence flag” for each section — green if the data was retrieved successfully, amber if the source was unavailable and the section is incomplete, red if a critical input is missing and the brief should not proceed without it.
Building It: The Practical Sequence
We built our version in n8n, but the same architecture works in Make or Zapier with OpenAI or Claude wired in. Here’s the sequence we followed, and the order matters.
Step 1: Define the brief template first. Before touching any automation tool, write out the brief your team would ideally receive. Every field in that template becomes a data source you need to connect. Starting with the automation first leads to a brief shaped by what’s easy to collect rather than what’s actually useful.
Step 2: Map data sources to fields. For each brief field, identify the source of truth. Be specific: not “competitor data” but “Meta Ad Library for [competitor name], scraped weekly, last 30 days of active creatives”.
Step 3: Build and test one module at a time. Collect and summarise one data source before moving to the next. The most common mistake is building the full pipeline at once and then having no idea which module is failing when something goes wrong.
Step 4: Write the prompts with constraints. Each summarisation prompt should include: the input data, the output format (bullet list, table, paragraph), the maximum length, and a fallback instruction for when the data is thin or missing. “If no competitor ads are found, output: No active creatives detected in the last 30 days. Flag this section amber.”
Step 5: Add the confidence layer. This is the quality gate. Green/amber/red flags on each section stop the brief from circulating when a key input is missing. This prevents the worst outcome: a strategy session where someone asks “did we check what the competitor is doing” and the answer is “the agent ran but didn’t find anything and nobody noticed”.
- Tools that work well: n8n (most flexible for custom connectors), Make (good UI, easier for non-technical users), Zapier (largest integrations library, more expensive at volume)
- Language models: Claude via API for structured outputs and longer context; GPT-4o for speed on shorter summarisation tasks
- Data storage: Notion for structured campaign notes; Google Sheets for audience performance data; raw JSON or Airtable for staging
Where This Connects to Broader AI Automation
The briefing agent is one workflow in a broader set of automations a marketing team can build. If you’re new to this kind of work, it’s worth reading how we think about AI automation for marketing teams before building individual workflows — the sequencing of what to automate first matters more than the tools you choose.
The briefing agent works especially well when it’s part of a campaign operations system rather than a standalone tool. Specifically, it pairs well with:
Post-campaign learning capture
The briefing agent can only retrieve previous learnings if those learnings were structured and stored. This means the loop only closes if your post-campaign review produces a consistent structured output. In client work, we’ve found that teams who run this agent also end up improving how they close out campaigns — because they know the notes will be retrieved next time.
Competitive monitoring
Rather than running a competitor scrape at brief time, you can wire the briefing agent into a continuous competitive monitoring feed. The agent then pulls from a live dashboard rather than triggering a fresh scrape. This reduces latency and means the brief reflects ongoing competitor activity rather than a single snapshot. We wrote about the mechanics of that setup in our post on AI for competitive monitoring.
Content calendar briefing
The same architecture applies to content calendars. Instead of campaign inputs, the agent pulls: top-performing content from last month, keyword opportunities flagged by your SEO tool, and any topics in the queue that map to current audience signals. The output is a content brief suggestion rather than a campaign brief, but the collection and summarisation logic is identical.
What We Don’t Automate in the Briefing Phase
This is worth being direct about. The agent handles information gathering. It does not handle:
- Interpreting contradictory signals (competitor is running aggressive discounts but your client doesn’t want to lead on price — the agent flags both, a human decides)
- Stakeholder alignment (the brief might say the target is SMB buyers, but if sales and marketing disagree on that, the agent doesn’t resolve it)
- Strategic framing (which angle to lead with, what the creative hierarchy should be, how to differentiate — this is the human job)
- Qualitative context that isn’t written down anywhere (a conversation the account lead had with the client last week, a nuance about the market that’s hard to document)
We’re careful about this framing because we’ve seen teams assume that a good briefing agent means briefings can happen without senior involvement. They can’t. The agent makes senior time more productive by removing the information-gathering burden. It doesn’t make junior time equivalent to senior time.
This connects to a broader principle we hold at Choco Media: AI handles the repetitive, structured, scalable work — the work where the same process produces the same output every time. Strategy, creative direction, and client relationships are the areas where we deliberately keep humans in control.
Results We’ve Seen From Running This System
We’re cautious about publishing specific numbers here because the results depend heavily on how organised the underlying data sources are. If your CRM is a mess and your campaign notes are scattered across twelve Slack threads, the agent can’t fix that — it will surface the mess. What we can say is what we typically see when the underlying data is reasonably structured:
- Time from “campaign kickoff triggered” to “brief in strategy lead’s hands” drops from a few hours to under 30 minutes
- The number of brief fields left blank or marked “TBD” at the start of strategy sessions drops substantially
- Teams report spending more of their strategy session on actual decisions rather than information sharing
- Post-campaign review quality improves as a side effect — because teams know the notes will be read next time, they write better notes
The less measurable but more important result: campaigns start from a shared information base rather than whoever happened to be paying attention last month. That consistency compounds over time.
Getting Started Without Building Everything at Once
The full system we’ve described can take several weeks to build properly. If you want to start smaller, here’s the 80/20 version:
Build one module first: competitor ad monitoring via Meta Ad Library. This is the most consistently high-value briefing input, it’s free to access, and the scraping logic is straightforward. Set it to run weekly, summarise to three bullets per competitor, and drop the output into a Notion page or shared doc. Run that for four weeks before adding anything else. You’ll get a feel for what’s useful and what’s noise before you build the full pipeline.
From there, add previous campaign learnings as the second module. This forces you to create a structured post-campaign note format, which is the foundational data source the agent needs. Most teams don’t have this yet — building it is the hardest part of the whole system, and doing it manually for a cycle or two before automating is usually faster than trying to automate it from the start.
- Week 1–2: Competitor ad monitoring module (Meta Ad Library + summarisation prompt)
- Week 3–4: Post-campaign note template + manual population for one past campaign
- Week 5–6: Wire the two together into a simple brief output
- Week 7+: Add audience data, client signals, and confidence flagging
Closing: The Brief Is the Strategy’s Foundation
We’ve written before about how AI changes what’s possible for small teams — not by replacing thinking, but by handling the work that doesn’t require it. The briefing phase is a good example of work that looks like it requires expertise but mostly requires diligence: collecting the same categories of information, from the same sources, in the same format, every time a campaign starts. That’s exactly what automation handles well.
If you’re looking at where to start with AI in your marketing operations, the briefing agent is one of the highest-leverage early builds. It’s visible — your team notices immediately when the brief arrives already populated. It’s contained — you’re not touching live campaigns, just the intake process. And it’s a foundation for everything else, because good briefs lead to better strategies, and better strategies compound over time.
If you’d like to talk through what this might look like for your team — what data sources you have, where the gaps are, and how to sequence the build — reach out and we can walk through it together.