SEA Agent Team: Multi-Agent Google Ads Workflow
Inspiration
Google Ads strategy, planning, and campaign execution is still a surprisingly manual and fragmented process.
Historically, building a professional search campaign meant spending 6 to 10 hours juggling between spreadsheets, character-counting tools, and the Google Ads Editor. A marketer has to act as a researcher, a strategist, a copywriter, a risk manager, and an analyst who reverse-engineers complex landing pages all at once.
The hardest part of this manual process is maintaining the "red thread" (der rote Faden). A marketer must ensure that every single step is interconnected: the core offer of the landing page must dictate the search intent, which must dictate the keyword clusters, which in turn must perfectly match the ad copy headlines. When doing this manually across different tools, this red thread easily breaks, leading to a loss of context, mismatched ads, and wasted budget.
As someone working in performance marketing, I realized that generic chatbots fail here. They don't understand strict technical structures or the strategic nuance required for search engine advertising (SEA). The Rapid Agent Hackathon inspired me to build a functional, autonomous expert team: SEA Team Lead. A Google ADK-based multi-agent system designed to maintain a flawless red thread and compress this multi-hour manual nightmare into a coordinated, automated, and safe 10-to-15-minute workflow—with the user always in control.
What it does
SEA Agent Team is an AI-driven marketing workspace that automates the end-to-end Google Ads campaign planning and deployment lifecycle while maintaining strict data relevance and safety.
Instead of forcing the user to manually piece together a strategy, the system orchestrates specialized agents to execute a highly sophisticated marketing pipeline:
- Landing Page Alignment: The system reverse-engineers the target landing page to ensure that every generated ad group, headline, and description perfectly matches the user's intent and final URL context, maximizing the Google Quality Score.
- Data-Driven Search Intent (Autocomplete Scraping): The system doesn't guess keywords. It utilizes a custom script that injects seed terms into Google Search, extracts real-time Google Autocomplete suggestions, and uses this actual search demand to construct high-intent keyword clusters.
- Automated Copywriting & Validation: The system drafts all Responsive Search Ads (RSAs), automating the tedious task of generating up to 15 headlines and 4 descriptions. Every line undergoes strict automated character-limit checks (max. 30/90 characters) to guarantee error-free deployment.
- Supervised API Deployment: It doesn't just generate text; it connects directly to a real Google Ads account. To ensure absolute safety, campaigns are strictly created as paused, utilizing a hardcoded safety budget of €1 and search-only configurations.
- Persistent Customer Memory: Powered by MongoDB Atlas via the official MongoDB MCP server, the system maintains a context-aware memory layer for every project. It remembers past strategies and keyword plans, preventing redundant regeneration, reducing wait times, and saving token costs.
Who benefits
Small and medium businesses without agency budgets currently face a brutal choice: either spend €2,000+ per month on an agency, or waste 6–10 hours per campaign doing it themselves with spreadsheets and the Google Ads Editor. SEA Agent Team removes that barrier entirely. A solo marketer, a startup founder, or a freelancer can now produce agency-grade campaign structures in 10–15 minutes — with real keyword data, validated ad copy, and safe one-click deployment. That's a 95% time reduction per campaign cycle, directly translating into lower cost-per-acquisition and faster go-to-market for businesses that previously couldn't afford professional search advertising.
The SEA Agent Team Workflow (Step-by-Step)
SEA Team Lead operates through a familiar chat interface, but underneath, it orchestrates a strictly sequenced, transparent, and interactive multi-agent pipeline:
1. Onboarding & Conflict Prevention (Team Lead Agent)
The user inputs a landing page URL. Instead of blindly guessing, the Team Lead Agent asks targeted questions: What is the target account? What is the daily budget? What is the core goal?
- Smart Exclusion: The agent asks which campaigns are already active (e.g., Broad Match, Product-specific, Generic). It notes these down to ensure the new setup does not cannibalize or compete with existing live campaigns.
- Persistent Memory: All setup details are instantly saved via the MongoDB MCP server.
2. Deep Context Ingestion (Landing Page Agent)
The Landing Page Agent scrapes and analyzes the provided URL, acting as a digital analyst to extract the exact offer, brand tone, and core USPs. This analysis is paired with the onboarding data and saved to MongoDB.
3. Live Demand Capture (Search Intent Agent)
The system passes the context to the Search Intent Agent. This agent executes a custom script that inputs seed terms into Google Search and captures real-time Google Autocomplete suggestions to find out exactly what users are typing.
4. Advanced Keyword Engineering (Keyword Agent)
Armed with real search intent data, the Keyword Agent builds the keyword architecture.
- Smart Placement Split: It assigns match types and categorizes each keyword: Should it be used directly in the ad copy, or is it too long (>30 characters) and should only be targeted in the backend? This solves a major real-world restriction of the Google Ads character limit.
5. Interactive Copywriting & UI Preview (Copywriter Agent)
Before writing, the Copywriter Agent asks the user how the ads should be structured. The user can select positioning preferences (e.g., Position 1: Brand Name, Position 2: USP, Position 3: CTA).
- Visual Validation: The agent generates the Responsive Search Ads (RSAs) and renders them in a custom Google Ads Design Preview inside the chat UI, complete with character-count visualizers for every headline.
6. Supervised Deployment (Campaign Builder)
The final stage is a strict, multi-step safety flow executed by the Campaign Builder:
- Naming Structure Validation: The agent automatically generates a standardized naming convention for the campaign and ad groups, which the user can review and edit.
- Account Selection & Confirmation: The builder prompts the user to select the final Google Ads account and displays a clean summary card of everything that will be created.
- Safe API Execution: Only after the user hits "Confirm", the agent makes the live API call. Once completed, the Team Lead reports back with a success message, confirming that the campaign has been successfully deployed as paused with a strict €1 safety budget.
How I built it
Tech Stack
- AI & Orchestration: Python, Google ADK, Gemini Flash
- Backend & APIs: FastAPI, Google Ads Python Library
- Database & Memory: MongoDB Atlas (via official MongoDB MCP server), pymongo
- Frontend: React, Vite, Tailwind CSS, Firebase Auth
- Exports: openpyxl (Excel / Google Sheets)
By leveraging Google ADK, I moved away from monolithic, unpredictable prompts and instead modeled the workflow like a real marketing agency. Each agent focuses purely on its core competency.
MongoDB Atlas is the central nervous system of the entire pipeline. Every agent reads from and writes to shared customer profile documents via the official MongoDB MCP server. When the Landing Page Agent extracts USPs, they're persisted to MongoDB. When the Strategy Agent builds a campaign structure, it first queries MongoDB for existing context. When the Keyword Agent generates clusters, they're stored for the Copywriter to retrieve. This shared memory layer is what maintains the "red thread" across all ten agents — without it, each agent would start from zero, and the strategic coherence that makes the output production-ready would be lost.
A key architectural decision was requiring agents to return a hybrid response: human-readable expert reports for the polished UI experience, coupled with strict JSON blocks at the end of every agent response. This lets the UI render beautiful explanations, visual ad previews, and data tables while extracting structured data for MongoDB storage and final Google Ads API execution.
The MongoDB MCP server is utilized as a visible part of the agent workflow. The user can see tool-use chips whenever the agents connect, search, or update customer memory, making the persistent memory layer observable instead of hidden in the background.
Challenges I ran into
Transforming Google Ads Knowledge into the "Agent Brain": The biggest conceptual challenge was translating years of human marketing expertise, industry best practices, and rigid platform logic into individual agent behaviors. I had to architect how a "Strategy Agent" passes context without losing the red thread, how a "Keyword Agent" separates ad-copy terms from backend terms based on character counts, and how a "Team Lead" prevents campaign cannibalization. Prompting alone wasn't enough; it required mapping out a strict cognitive workflow for the entire system.
Moving from "AI Output" to Real-World API Execution: A Google Ads campaign requires strictly structured nested objects, valid campaign settings, budgets, bidding strategies, ad groups, and character-perfect ad copies. To ensure absolute reliability and prevent API rejections, I implemented strict validation loops: requiring JSON blocks from agents, embedding full structural examples in the agent prompts, adding character-count validations in code, and using deterministic rules where LLM autonomy wasn't safe.
Balancing Autonomy with Control: The system should feel like an automated specialist team, but it should never silently publish campaigns without review. This is why the Google Ads publishing flow uses multiple confirmation steps, a standardized naming convention editor, and safety constraints (paused state, €1 budget).
Accomplishments that I'm proud of
I am proud that SEA Agent Team does not stop at generating a static marketing plan. It compresses a multi-hour expert process into a 10-to-15-minute orchestrated workflow that securely pushes live data into a real Google Ads account.
I am also incredibly proud of the interface. Instead of showing one long, boring AI response, the app renders structured strategy tables, keyword tables, match-type labels, real-world Google Ads design previews, account picker cards, and real-time tool-use chips for the MongoDB MCP integration.
Finally, I am proud that I built this full-stack application entirely as a solo project: from the multi-agent orchestration via Google ADK and the custom autocomplete scraper to the complex Google Ads OAuth and API publishing flow.
What I learned
I learned that building useful agents requires deep orchestration rather than just strong prompting. The real value lies in defining exactly which agent should act, what structured data should flow between steps, when memory should be checked, and where deterministic code must override the model to enforce strict technical guardrails (like character counts).
I also learned that memory is only valuable when it actively alters the workflow. Using MongoDB Atlas via MCP allowed the Team Lead to truly "recognize" repeat requests, directly showing saved workspace campaigns and avoiding unnecessary API or token consumption.
What's next
Next, I want to connect the Optimizer Team an experimental sub-team already built into the pipelineto live Google Ads reporting through GAQL. This will allow the agents to analyze campaign performance, search terms, CTR, Quality Score signals, and conversion data to optimize active campaigns.
I also want to scale the existing Cloud Run deployment with Google Cloud Secret Manager for enterprise-grade credential storage, and implement a deeper memory system that spans across multiple landing pages of the same root domain to create a true omni-channel advertising brain.
The long-term vision is to turn SEA Team Lead into the ultimate supervised AI workspace for search advertising: an agent team that can plan, build, remember, publish, and optimize Google Ads campaigns with the marketer always firmly in control.
Log in or sign up for Devpost to join the conversation.