Skip to content

Checks

Ad account guardrails

Checks an AI agent's access to your ad accounts before it acts, with read-only first, logged reasoning, and people on budgets and bids.

Other tools

Add this skill to Claude

Claude takes skills as a ZIP file. Your download has started; if it didn't, use the button below.

  1. 1In Claude, open Customize, then Skills.
  2. 2Choose +, then Upload a skill, and pick agent-guardrails.zip.
  3. 3Ask for it by name, or let Claude use it when a task matches.

Skills need code execution turned on in Claude's settings. On a Team or Enterprise plan, an admin can share it with everyone.

Download the folder

Try it now, without installing

See the skill work on a made-up input before you add it. Nothing is installed, and you can swap in your own input.

Open in the Claude app

Opens a new chat in the Claude desktop app with the prompt filled in. Nothing is sent until you press enter.

Includes the whole SKILL.md and the sample input. Paste it into Claude, ChatGPT or any chat.

Influenced by
What agentic PPC looks like in practice
Needs
What the agent can do, its role on each platform and its tools · Who approves its changes, and how
Works with
Claude, ChatGPT, Codex, Cursor and any agent that reads SKILL.md
Version
1.0.0 · Last checked · License MIT
Maintained by
Sabih AhmedPaid media
SkillPaid media

Ad account guardrails

Example output

Check an agent before it acts
CheckFoundCall
RoleRead onlyPass
Budget toolsNonePass
Change historyNot matched yetNote

Checks an AI agent's access to your ad accounts before it acts, with read-only first, logged reasoning, and people on budgets and bids.

The skill

The whole skill, in plain text.

Nothing is hidden. Read it, change it to fit your team, or take the whole folder.

Scripts
Optional Python scripts for the counting. It works without them and says which way it ran.
Network
Opens web pages or your tools if your agent can. Works from pasted data if not.

3 test cases

agent-guardrails/SKILL.md

In the folder

  • agent-guardrails/SKILL.md
  • agent-guardrails/scripts/audit_log.py
---name: agent-guardrailsdescription: >-  Checks an AI agent's access to an ad account (Google Ads, Microsoft Ads, LinkedIn, Meta, Reddit, ChatGPT Ads)  before it acts: read-only first, a reviewed trial of its suggestions before any write access, a reasoning log that  matches the platform's change history, before-values for every change, and people, never the agent, on budgets,  bids, bid strategies, targets, billing and user access. Audits the log against the change history with a script.  Returns PASS, PASS WITH NOTES, FAIL or BLOCKED with severities. Use it before connecting an agent, MCP server or  automation to an ad account, before widening its access, and monthly while it runs. Not for auditing the account's  performance (use search-terms-triage or lead-value-math).license: MITcompatibility: >-  Works in Claude, ChatGPT, Codex, Cursor and any agent that reads SKILL.md. Reads the agent's setup, permissions and  logs from what the reader shares; uses a connected ad account only to read its change history. Python 3 is  optional, for the log audit.metadata:  author: SHAKEUP  version: "1.0.0"  stage: check  plugin: paid-media  homepage: https://www.shakeuphq.com/skills/agent-guardrails--- # Ad account guardrails Makes sure an AI agent can only do what a person has agreed to, and that every change it makes can be explained and reversed. ## Purpose - One job: check one agent's access to one ad account (or one set of accounts) and return pass or fail with severities and fixes.- Stage: check. It ends in a verdict.- It never grants, removes or changes access, and never changes the account. It recommends; the reader applies.- It holds one rule above all: budgets, bids, bid strategies, targets and bid adjustments stay with people. ## Use when / not | Situation | Use || --- | --- || Before connecting an agent, MCP server, script or automation to an ad account | this skill || Before giving an agent write access, or more of it | this skill || Monthly, while an agent runs, to reconcile its log with the change history | this skill || Reviewing the account's performance | `search-terms-triage`, `lead-value-math` || Running the weekly ad operations as an agent | `adops-agent`, which runs this check first | ## Inputs | Input | Required | Ways to provide, in order | If missing || --- | --- | --- | --- || What the agent can do: its permission level on each platform, and the tools or functions it can call | yes | the agent's configuration or tool list; the platform's user access page; the reader's description | ask once; `BLOCKED` || Who reviews and approves its changes, and how (per change, per batch, after the fact) | yes | the reader | ask once; without a named person, every write path is critical || The agent's reasoning log | no (yes once it can write) | a CSV or JSON lines export; pasted rows | logging is checked from the description only; with write access, the missing log is critical || The platform's change history for the same period | no (yes once it can write) | a connected account (read); the change history export | reconciliation not run, coverage `partial` || The trial record: how long suggestions were reviewed, and how many were accepted | no | the reader | write access without a recorded trial is a warning || How credentials are stored | no | the reader | ask; never ask for the credential itself || The data sources the agent reads, and whether each is described to it | no | the reader; the agent's instructions | warning | ## Profile read From `company-profile.md`: `## Accounts and data` (ad accounts, connected tools), `## Channels` (owners: the people who should approve), `## Targets` (max CPL, so a spend-related action can be sized), and every `## Learnings` entry for `agent-guardrails` with status `noted`, `fact` or `accepted`. No profile: ask in one message for the platforms, who owns each account, and who approves changes. Say that `company-profile` saves this next time. Never ask for passwords, API keys or tokens, and tell the reader not to paste them. ## Steps 1. **Apply learnings.** A past incident (an agent change that wasn't logged, a runaway rule) raises its severity. Name each one that fires. 2. **Map the access** to the tiers. Every action the agent can take falls in one tier:    | Tier | What the agent may do | Who acts |   | --- | --- | --- |   | 0 Read | read reports, search terms, settings and the change history | the agent |   | 1 Draft | write proposals to a sheet, a document or Editor files; create items only as paused drafts that can't serve | the agent drafts; a person applies |   | 2 Apply with approval | add negatives, pause keywords or ads, add paused ads, each batch approved by a named person before it applies | a person approves; the agent applies and logs |   | Never | change budgets, bids, bid strategies, targets or bid adjustments; enable campaigns, ad groups or ads; change conversion settings or tracking; billing; user access | people only, at every tier |    Use the platform's least access that covers the tier: a read-only role for tier 0 and 1. Platforms name roles differently; read the user access page and record the role. 3. **Check the path to each tier.**    | Check | Pass when | Why |   | --- | --- | --- |   | Read only first | the agent started at tier 0 or 1 | its suggestions can be judged before they can cost anything |   | Trial before write | before tier 2, its suggestions were reviewed for at least 2 weekly cycles, with what was accepted and rejected recorded | one cycle can't show it is consistent |   | Named approver | each tier 2 action has a named person who approves it before it applies | someone owns every change |   | Never list enforced by access | the agent's role or tool list can't reach the never list, not only its instructions | an instruction can be ignored; a missing permission can't |   | Official integration | the agent uses the platform's official API or a connector built on it, not browser automation | automated activity outside official routes risks policy violations and account bans | 4. **Check the log.** Every proposed or applied change has: time, account, entity, field, before-value, after-value, the reason with the data behind it, who approved, and whether it applied. Run `python3 scripts/audit_log.py --history change_history.csv --log agent_log.csv --agent-user <the agent's user>`: it finds budget or bid changes by the agent, changes the history shows that the log doesn't, log values that don't match the history, logged changes the history doesn't show, missing reasons, approvals and before-values, and the same setting changed more than once in 7 days. Without Python, match each agent row in the history to a log row by entity, field and day, by hand, and say so. 5. **Check the limits.**    | Check | Pass when | Why |   | --- | --- | --- |   | Rate limit | no setting is changed more than once in 7 days | a change needs 7 days before it can be judged; faster changes make results unreadable |   | Batch size | each approved batch is small enough for the approver to read every line | a batch nobody reads is not approved |   | Rollback | every change has a before-value, so it can be reversed | a change without one can't be undone cleanly |   | Kill switch | a named person knows how to revoke the agent's access in one step, and where | stopping it shouldn't need the person who built it |   | Tool surface | the agent exposes no more than about 12 tools or functions, each with one job | practitioners report agents getting worse past roughly 10 to 12 functions; a small core set is easier to check |   | Data described | each data source the agent reads is explained to it (for example, "conversions are form fills, not opportunities") | without it, the agent optimizes the wrong thing confidently |   | Credentials | tokens stored in a secrets store, scoped to the accounts it needs, never in the profile, a chat or a shared document | a leaked token is full access | 6. **Write the fixes.** For each finding: the severity, what was found, and the fix (remove the permission, move the action to a person, add the field to the log, set the rate limit). ## Check and verdict Severity: | Severity | Findings || --- | --- || critical | the agent can reach anything on the never list; write access with no named approver; write access with no reasoning log; a change in the history the log doesn't show; a log value that doesn't match the history; a change without a reason; credentials in a profile, chat or shared document || warning | write access without a recorded trial; no rate limit, or a setting changed twice in 7 days; changes without before-values; no kill switch named; more than about 12 tools; data sources not described; an unofficial integration; a logged change the history doesn't show; no change history to reconcile against while the agent can write || suggestion | anything that would make review faster, such as alerts on new changes or a separate log per account | | Verdict | Condition (first match wins) || --- | --- || `BLOCKED` | What the agent can do is unknown after one question || `FAIL` | 1 or more critical findings || `PASS WITH NOTES` | Warnings or suggestions only || `PASS` | No findings | Named stops: `BLOCKED` asks for the agent's permissions and tool list. `FAIL` says the agent should stay at, or go back to, read-only until every critical finding is fixed. No other stops. ## Learn Append to `## Learnings` when: - an incident happens (an unlogged change, a change that cost conversions, a runaway rule): a `fact` with the date, the change and the fix;- the agent moves up a tier: a `fact` with the trial record and who approved it;- the reader accepts a warning as a known risk: a `fact` with their reason and a review date;- a monthly audit passes with no findings 3 times in a row: a `proposal` to widen the batch size, never the never list. Example: `- 2026-10-24 | agent-guardrails | fact | The agent's MCP server exposed a budget function; removed and access set to read only | Why: monthly audit found 1 budget change by the agent user on 2026-10-01 | Status: noted` ## Output ```Verdict: <PASS | PASS WITH NOTES | FAIL | BLOCKED> · Coverage: <complete | partial (what wasn't available)> · Log audit: <script | by hand | not run>Counts: <n> critical, <n> warnings, <n> suggestions Access map| Platform | Role | Tier | Actions it can reach | On the never list? | | Severity | Check | Found | Fix |(critical first) Log audit: <agent changes, log entries, unlogged, mismatches, budget or bid changes, too frequent>Next tier: <what must be true before it moves up, or "stay at read only">Learnings applied: <list, or none>``` Then the handoff block. ## Hand off ```handoffskill: agent-guardrailsversion: 1.0.0verdict: PASS WITH NOTEScoverage: completefor: <agent> on <accounts>outputs:  tier: 1  critical: 0  warnings: 2  never_list_enforced_by_access: true  next_tier_when: 2 weekly cycles of suggestions reviewed and recordednext: [adops-agent]open: [name a kill switch owner]``` `adops-agent` runs this check before each run and works only at the tier it returns. ## Failure modes | Problem | Do this || --- | --- || The reader pastes an API key or token | Don't repeat or store it; tell them to rotate it and keep it in a secrets store || The agent's tools are hidden behind a vendor's product | Ask the vendor for the list of actions it can take on the account; until then, treat every action the role allows as reachable || The change history shows a person's change the log attributes to the agent | Mismatch: the log is unreliable until fixed || The agent changes bids through an automated rule the reader created | Still a bid change by an automation: on the never list, critical || The platform's change history only covers a short period | Reconcile what exists, say the period, and audit monthly so nothing falls out of the window | ## Influenced by - Frederick Vallaeys' PPC Town Hall conversation with Benjamin Wenner on agentic PPC in practice (Optmyzr): start in read mode, review an agent's suggestions before letting it act, compare its reasoning logs with what actually changed, keep a small set of functions, and keep budgets and bids under human control: https://www.optmyzr.com/ppctownhall/what-agentic-ppc-actually-looks-like-in-practice/- SHAKEUP's B2B Google Ads playbook: a change log with the reason and the expected result for every change, one change at a time, 7 days before judging it, and budget allocation as a human decision.

How it thinks

Inputs in, a verdict out, and a stop only where you decide.

What we built

An agent can be wrong confidently, and a wrong change in an ad account costs money before anyone sees it. So access starts read only, rises one tier at a time on a reviewed record, and budgets and bids stay with people at every tier.

It reads your company profile if you have one, or asks for only what it needs. Then it works through its steps, checks its own work and ends in a verdict.

The steps

  1. 01

    Read your learnings first

    A past incident, such as an unlogged change, raises the severity of the same finding.

  2. 02

    Map every action to a tier

    Read, then draft, then apply with approval. Budgets, bids, targets, billing and user access stay with people at every tier.

  3. 03

    Check the path between tiers

    Read only first, at least 2 weekly cycles of reviewed suggestions before write access, and a named approver for every batch.

  4. 04

    Check the never list is out of reach

    The role or tool list must block budget and bid changes. An instruction alone isn't enough.

  5. 05

    Match the log to the change history

    Its script finds changes the log doesn't show, log values that don't match and any budget or bid change by the agent.

  6. 06

    Check the limits

    A rate limit, before-values for rollback, a kill switch, a small tool set, described data and credentials kept out of chats.

What you need

  • Required

    What the agent can do, its role on each platform and its tools

    The agent's configuration or tool list → The platform's user access page → Your description

  • Required

    Who approves its changes, and how

    Your answer

  • Optional

    The agent's reasoning log

    A CSV or JSON lines export → Rows you paste

  • Optional

    The platform's change history for the same period

    A connected account, read only → The change history export

  • Optional

    The trial record of its suggestions

    Your answer

What it can return

  • PASS

    No findings, so the agent can work at the tier it was checked for.

  • PASS WITH NOTES

    Warnings only, such as no recorded trial or a log that couldn't be matched yet.

  • FAIL

    The agent can reach budgets, bids or billing, or a change has no reason, approver or log entry.

  • BLOCKED

    What the agent can do is unknown.

Where it stops for you

  • When what the agent can do is unknown
  • When any critical finding means the agent should go back to read only

Example output

What you get back.

A run for a made-up company. Your output depends on your inputs.

Here's a check for a made-up B2B SaaS company that wants an AI agent to work on its Google Ads account.

Verdict

PASS

Coverage: complete

Log audit: not needed yet, since the agent can't write

PlatformRoleTierActions it can reachOn the never list?
Google AdsRead only, official API1, draftReports, search terms, change history, a proposals sheetNone
CheckFound
Read only firstYes, 4 weeks so far
Trial record31 of 40 proposals accepted by the demand gen manager
Named approverThe demand gen manager applies every change in the editor
Tools6, each with one job
CredentialsIn a secrets manager, scoped to one account
Kill switchThe approver can remove the agent's user in one step
Before tier 2

limit write access to negatives and pauses, approve each batch before it applies, and match the agent's log to the change history every month.

The handoff block the next skill reads
skill: agent-guardrails
version: 1.0.0
verdict: PASS
coverage: complete
for: ads agent on Google Ads
outputs:
  tier: 1
  critical: 0
  warnings: 0
  never_list_enforced_by_access: true
  next_tier_when: write access limited to negatives and pauses, batch approval, monthly log audit
next: [adops-agent]
open: []

What good looks like

  • Every action the agent can take mapped to a tier
  • Budgets, bids and billing blocked by access, not by instructions
  • A log that matches the change history line by line
  • A before-value for every change, so it can be reversed
  • A named person who approves, and one who can switch it off

Install

Use it in the tool you already have.

Pick your tool. Each tab has the shortest path we know of.

  1. 01
  2. 02
    In Claude, open Customize, then Skills.
  3. 03
    Choose +, then Upload a skill, and pick the ZIP. Code execution must be on in your settings.
  4. 04
    Ask for it by name, or let Claude use it when a task matches.

Questions

Before you add it.

Why can't the agent change budgets or bids?

Because those changes cost the most when they're wrong, and they compound overnight. The agent can propose them with its reasoning, and a person decides.

What does matching the log to the change history catch?

Changes the agent made but didn't log, and logs that describe changes that never happened. Practitioners have found that agents' stated reasoning doesn't always match what they did.

How does an agent earn write access?

At least 2 weekly cycles of suggestions reviewed by a person, with what was accepted recorded. Then it applies negatives and pauses only after a named person approves each batch.

Does it need my API token?

No. It never asks for one. If you paste one, it tells you to rotate it and keep it in a secrets store.