Google Ads Scripts vs MCP Agents: When Code Loses

Google Ads scripts are cron jobs: they run on a schedule and answer the questions you thought to code, back when you wrote them. An MCP agent answers the question you have right now, in plain language, against live data — then executes on it, building campaigns and moving budgets and bids in seconds, on your approval. Framed that way, the comparison stops being a fight. They are different tools for different halves of the job, and the accounts that run best in 2026 use both. What follows is the honest division: where scripts keep winning, where they cannot follow, and how the two compose.

What scripts genuinely do best

Scripts earned their place and keep it for one reason: they run when you are not there.

• Time-triggered alerts. Spend spikes overnight, a campaign serves zero impressions by 9am, a landing page starts returning errors — a script catches these at 6am and emails you. No conversational tool does this, because conversations need someone to start them.
• Scheduled pacing mail. A daily spend-versus-target email to the team costs nothing once written and never forgets to send.
• Mechanical hygiene on a timer. Pausing ads when a promo ends, checking final URLs weekly, labelling anything that breaches a threshold.

They are also free, run inside Google's own infrastructure, and need no third-party access grants. For pure clockwork, scripts remain the right answer, and nothing in this article argues otherwise. The mistake is not using scripts — it is using them as the answer to every question, which their own limits make impossible.

The hard limits: 30 minutes, no campaigns, and JavaScript upkeep

Three walls, all documented in Google's own limits page:

• The 30-minute runtime cap. A script is terminated at 30 minutes — Ads Manager scripts using parallel execution stretch to 60, which moves the ceiling without removing the wall. Large accounts hit it on exactly the analyses that matter most — full search-term sweeps, cross-campaign joins — forcing you to shard work across runs and stitch results.
• No direct campaign creation. Scripts modify existing entities. Creating a campaign requires the bulk-upload CSV workaround or leaving scripts for the API — which is why "just script it" has never covered the build half of account management.
• JavaScript upkeep. Every script is code you now own. Selectors change, methods deprecate, the person who wrote it leaves. Most accounts more than a few years old contain a scripts library best described as a graveyard: nobody is sure what still runs, what silently fails, and what would break if touched.

There is a fourth, softer limit that matters more than the three hard ones: a script only ever answers the question it encodes. The question you have today — why did CPA jump in one region last Tuesday — was not in last month's imagination, so no script exists for it. It answers with a chart when what you needed was an argument.

What an MCP agent changes

An agent connected over MCP — the open protocol originally published by Anthropic in late 2024 — gets a toolbox to read and run the account, and takes its instructions in language. The account cannot tell the difference — API calls either way — but the operator's day changes shape entirely. Three consequences:

• Ad-hoc questions are free. "Which search terms drove last week's spend rise, and were any of them new?" is a sentence, not a script project. The marginal cost of the next question drops to zero, which quietly changes how often you investigate at all.
• Cross-entity reasoning. The agent joins campaigns, keywords, negatives and search terms in one pass, and explains the join. Scripts can compute joins; they cannot decide which join tells the story.
• Writes with approval. The agent builds the change — new negatives, a budget move, a campaign staged paused — and executes the exact tool call the moment you approve. A hosted, write-capable MCP server exposes 32 tools to the connector — reads and writes, from search-term queries through campaign creation, budgets and scheduling — while deletion is deliberately absent: the remove tools are never exposed, and a REMOVED-status mutation is refused server-side rather than merely discouraged.

What the agent does not do: run unattended at 6am. It is prompt-driven by design. Anyone selling you an agent as a full replacement for scheduled automation has not run an account through a month-end.

Head-to-head on five real tasks

Task	Scripts	MCP agent	Verdict
Alert when spend spikes overnight	Fires on schedule, every day	Only when asked	Scripts
"Why did CPA rise last week?"	Not without pre-written logic per cause	Reads change history, terms, auctions — answers with evidence	Agent
Create a search campaign	CSV bulk-upload workaround only	Drafts it, you approve, it lands paused or live	Agent
Monthly n-gram waste report	Classic script — but you maintain the code	One saved prompt, judgement included	Agent, narrowly
Daily pacing email to the team	Set once, arrives forever	Needs a human to ask	Scripts

The pattern is clean: clocks favour scripts, questions favour agents, and anything requiring judgement about what to do next favours agents decisively.

Three rows deserve a note. The overnight alert is not close — and never will be, because the entire premise of an agent is a human in the conversation. The CPA investigation is not close in the other direction: a script that diagnoses causes would need every possible cause coded in advance, which is a research programme, not a script. And campaign creation is a difference in kind, not just capability — the bulk-upload workaround exists, but a campaign drafted in conversation, arriving paused for review with ad groups, keywords, negatives and an RSA each, is delegation; authoring CSV columns is data entry with extra steps. The n-gram row is the narrow one: scripts genuinely handle it, and the agent wins on total cost of ownership — no code to maintain, thresholds changed by saying so, and the judgement about which fragments become negatives included in the same pass rather than left as an exercise for the reader.

The hybrid setup: scripts for triggers, agents for investigation

The strongest configuration treats the script as a smoke detector and the agent as the person who finds the fire.

1. Keep a small, curated script set that only detects and notifies: overnight anomalies, zero-impression checks, pacing thresholds.
2. When an alert lands, open your AI client and hand the agent the lead: "Spend alert on account 123 — spend doubled versus the daily average. Find the cause, show the evidence, and propose the fix."
3. The agent investigates across entities in minutes, proposes the change, and executes it after your one-click approval — attributed to you, logged in the audit trail.

The alert took code you wrote once. The investigation took a sentence. Neither tool alone covers both halves, and the escalation stays clean because the alert text itself carries the scope — account, campaign, metric — so the investigation starts scoped instead of starting from scratch. This division also scales across a portfolio — for the multi-account version of the pattern, see managing many accounts with one AI chat.

Cost, honestly: scripts are free in cash and expensive in engineering attention; an agent costs a subscription plus the AI client you already pay for, and returns the attention. Which trade wins depends on whose hours you are spending — and the seven-day pilot exists precisely so the comparison can run on your own account rather than in the abstract.

The migration path when your scripts library is a graveyard

If you have inherited fifteen scripts of unknown provenance, do not port them — triage them. Porting preserves effort; triage preserves value, and in a graveyard the two point in opposite directions.

1. Inventory. List every script, its schedule, and its last successful run. Anything failing silently for months has already told you its value.
2. Sort into detectors and answerers. Detectors fire on time and send a message. Answerers compute analysis — n-grams, waste sweeps, quality audits.
3. Keep the detectors, retire the answerers. Every answerer becomes a saved prompt against the agent — same question, live data, zero maintenance, and a judgement layer the script never had.
4. Route the rest through the automation map. Some of what scripts once did now belongs to Google's native layers; the Google Ads automation guide covers which layer owns what, and API access covers the cases where real code is still the right call.
5. Re-run the inventory quarterly. Scripts regrow — someone finds a blog post, pastes a scheduler, forgets it. The discipline that triaged the graveyard is what keeps it from refilling, and the audit takes minutes once the library is small.

Most libraries shrink to three or four genuine schedulers. What replaces the rest is not more code — it is the standing ability to ask.

Start a free pilot and run the script inventory as your first session.