Most ad ops is a person in a browser doing the same thing to the same platform for the hundredth time. Most ad ops automation is a folder of scripts that one person understands. We do it a third way: AI agents, run from the command line, working the platforms through their APIs, with the platform knowledge kept in a memory system rather than in someone's head. Here is what that actually means in practice.

The setup

  • An agent in the terminal. We use Claude Code, Anthropic's command-line agent. It reads and writes files, runs scripts, calls APIs and reports back. It is the operator; we are the ones giving it work and approving it.
  • Platform APIs, not the UI. Adform, DV360, The Trade Desk, Google Ad Manager and Campaign Manager 360 all have APIs. The agent traffics, tags, pulls stats and updates settings through them. Browser automation is the last resort, only for the few things a platform has no API for, and never for writes.
  • Skills. Every repeatable job is written down as a playbook the agent loads before it starts: how to upload HTML5 to Adform, how to create direct tags, how to reconcile a report. The playbook carries the rules, the non-negotiables and the checks. A new job on the same platform starts from the playbook, not from scratch.
  • Memory. Every gotcha we hit goes into a memory file the agent reads at the start of each session: the stats API that silently stops at 50,000 rows, the zip that lowercases filenames, the tag endpoint that needs two calls. A mistake gets made once. That is the whole point of the memory system, and it is the part a human team can never quite match.

A normal morning

A reporting agent wakes at six, pulls yesterday's numbers from three platforms, reconciles the totals against a second low-cardinality pull, renders a card and posts it to the team's Telegram. A refresh checker makes one stats call and only speaks if a campaign's newest banner is more than 30 days old. A clicktag audit sweeps every banner uploaded in the last eight days and alerts on any bundle with no click wiring. None of this needs a person. If everything is fine, nobody hears from it.

Then the work that does need a person. A client wants a creative changeover across four campaigns. I open the terminal and describe it. The agent loads the tagging skill, reads the memory notes for that platform, works out the 76 line items involved, and produces a dry run: what it will deactivate, upload, create and set. I read the plan. I say yes. It runs, waits on the rate limits, reads back every one of the 532 tags it created, and writes the log. An afternoon, with the audit trail included.

The rules the agent works under

  • Dry run first, always. Any bulk change is shown as a plan before it happens. Nothing above a handful of records is created on a vague instruction.
  • Explicit yes for writes. The agent does not push to a live platform because a conversation implied it should. It waits for the word.
  • Verify, do not trust. After every write, it reads the thing back. A 200 OK from an API is not proof the platform kept what you sent; we learned that one the hard way with server-side conversions.
  • Pace like a polite human. Rate limits are respected by design. A blocked API key costs a day.
  • Never automate writes through a UI. Autocomplete once corrupted 21 rows of a spreadsheet through a browser. Reads through a browser are fine; writes go through APIs or a file the human imports.
  • Report honestly. If a step failed, the report says failed. If a step was skipped, it says skipped. The agent's summary is what the human reads, so it has to be true.

Why not just hire an ad ops person

Hire one anyway, for judgement. What the agents remove is the repetition and the forgetting. A person who has hit the 50,000-row cap once will probably remember it. Their replacement will not. A memory file does not leave, does not go on holiday and does not get tired at 5pm on a Friday when the 300th banner needs checking. The human's job becomes deciding what to do and approving it, which is the part that was always worth paying for.

Why not just write scripts

We do write scripts; the agent writes most of them. The difference is what sits around them. A script folder has no memory of why a check exists, no playbook a newcomer can follow, and no operator who reads the dry run and asks whether the plan is right. The agent reads its own memory, applies the skill, runs the script, checks the result and explains it. That is the layer that turns a pile of automation into an operation.

Where it goes next

More of the day-to-day moves to the agents as we trust each piece: pacing checks, discrepancy reconciliation, creative refresh, DCO feed hygiene. The human gate stays where money moves or something goes live. That balance, agents doing the work and people approving the plan, is the operating model behind every service we sell.