Skip to main content
Claude Cowork is Claude’s brand-aware workspace mode. Set up a Cowork project for ad ops once and it becomes an always-on co-worker: it builds campaigns from your briefs, verifies them against your rules, and optimizes the live ones on a schedule — all through the Adspirer MCP connector. The teams who get the most out of this don’t just chat with the agent ad hoc. They give the Cowork project a durable setup with three moving parts:

Project instructions

The agent’s always-on “constitution” — its role, its hard rules, and how it works. Read on every task.

Skills

On-demand playbooks for specific jobs (build a search campaign, optimize a portfolio). Loaded only when the task calls for them.

Scheduled tasks

Automation. The same Cowork agent, run unattended on a schedule, making bounded, guardrailed changes and posting a summary.
This guide gives you a copy-paste template for each, plus the safety model that makes unattended automation trustworthy.
Haven’t connected Cowork yet? Start with Connect Claude Cowork, then the Agent Skills overview and Core Workflows — then come back here to wire them into an always-on setup.

​
The mental model

A Claude Cowork project has four lanes. Keeping them separate is the most important setup decision — mixing them is the most common mistake. Golden rule: skills stay skills. Reference them by name from your instructions and your task prompts. Don’t paste a skill into the Instructions field, and don’t drop playbooks into the Context folder — Context is for data, not procedure.

​
Step 1 — Create the Cowork project and connect

1

Create a Cowork project

In Claude Cowork, create a project for this work (e.g. “Paid Media — Ad Ops”). Everything below lives inside it, so scheduled tasks inherit the same instructions, skills, and connectors.
2

Connect Adspirer MCP

Connect Adspirer (mcp.adspirer.com/mcp, OAuth) and link the ad accounts you’ll work in. Confirm the exact account IDs — the agent should never guess which account it’s operating on.
3

Connect a notification channel

Add Slack (or email) so scheduled tasks can post what they did. Unattended automation must report every run somewhere a human watches.
4

Connect your source of briefs (optional)

If your campaign specs live in Google Drive or a sheet, connect that too so the agent can fetch them as Context instead of you pasting each one.
5

Leave memory on

Project memory lets the agent reuse prior builds, naming conventions, and decisions across sessions.

​
Step 2 — Write the project instructions

This is the agent’s constitution. Paste it into the Cowork project’s Instructions field. The goal is to make the safe behavior the default, so you never have to babysit it. The non-negotiables that make ad-ops agents safe:
  • Confirm before building. Parse the request, show the plan and a validation report, and wait for explicit go-ahead before creating anything live.
  • Build paused, never launch. Every campaign is created paused; turning it on is a human decision after sign-off.
  • Validate, don’t edit. If approved copy exceeds a platform limit, stop and report the exact field and length. The fix is new approved copy, never the agent’s own rewrite.
  • Preserve what’s locked. Approved creative, tracking parameters, names, and targeting are passed through verbatim. Flag a problem; don’t “fix” it.
  • Read before you retry. Creation tools execute for real and can be slow. If one times out, read the current state first — a timeout may have succeeded.
  • Two monitoring modes, and they’re different (see Step 4): a human chatting with the agent gets read-only analysis; a scheduled task is pre-authorized to act within guardrails.

​
Step 3 — Add skills (on-demand playbooks)

A skill is a focused, reusable playbook for one job. Cowork loads it only when the task matches, so you can give the agent deep, exact procedures without bloating every conversation. Adspirer ships a set of skills you can install as a starting point, and you can write your own. What makes a good ad-ops skill:
  • One job, fully specified. “Build a search campaign from a brief” or “optimize a portfolio on a schedule” — not “do marketing.”
  • A clear workflow. The exact order of operations and the tools at each step.
  • Inherited invariants. State what it must never do (e.g. never broad match, never touch locked copy) so the rule holds even mid-task.
  • Validation built in. Where it measures against platform limits and stops.

​
Step 4 — Automate with scheduled tasks

A Cowork scheduled task is the same project agent, run unattended on a cadence. Because no human answers a prompt mid-run, all the safety has to live in the rules, not in a permission prompt. This is where the design matters most.

​
The safety model for unattended changes

These seven properties are what make a self-driving optimizer trustworthy. They are platform-agnostic — the same shape works for Google, Meta, LinkedIn, or TikTok.

Shadow mode by default

A MODE: shadow switch makes the task compute and report what it would do, but write nothing. New tasks start here for a week.

Hard guardrails

Per-run change caps (e.g. ≤±20%/run), a spend cap it can never exceed, a daily floor, and a cooldown so a lever changes at most once per N runs.

Single writer

One task owns one portfolio. No two tasks ever touch the same campaign, so there’s no write conflict and one clear audit trail per scope.

Propose vs. act

Small, reversible changes auto-apply. Pauses, big moves, and anything beyond a cap are proposed — applied next run only after a human approves.

Catch-up safe

Every number is read from live state at run time. A skipped or late run recomputes from current spend instead of compounding a stale assumption.

Notify every run

Acted, proposed, or nothing — each run posts a summary to your channel so a human can always see and reverse it.
Plus a kill switch: flip MODE: shadow (or pause the task) and all writes stop immediately, everywhere that task runs.

​
Put the rules in the skill, the scope in the task

Keep the thresholds, decision logic, math, and report format in one optimizer skill, so a single edit updates every task. The task prompt just names the skill, the platform, the campaigns/pool, and the cap.
The task prompt is short because the skill carries the logic. A portfolio-optimizer skill is typically organized as:
  • Operating principles — guardrails are hard limits; compute from live state; don’t double-act; smallest reversible change first; kill switch; always notify.
  • Per-run flow — READ → GUARD → SCORE → DECIDE → SHIFT → APPLY → LOG + NOTIFY.
  • Signals — what to read per campaign over trailing 7d and 30d (discount the last 1–2 days for attribution lag).
  • Classification — winner / efficient-not-capped / steady / underperformer / dead / insufficient-data, each with a numeric condition you tune to your targets.
  • Decision tree — efficiency × capacity: a strong campaign that is budget-limited gets more budget; a strong one that isn’t limited just holds (more budget buys no extra volume); weak ones reduce; dead ones propose a pause.
  • Pacing math — every budget number is clamped to a glide path: remaining ÷ days_left, never letting projected month-to-date exceed the cap.
  • Hard guardrails — the per-run caps, cooldown, data minimums, and pool integrity.
  • Auto vs. propose table — exactly which changes apply automatically and which wait for approval.
  • Report template — the per-run summary format.
Keep every threshold as a tunable default and refine it from real results. The structure is the contract; the numbers are yours to tune.

​
Rolling it out safely

1

Start in shadow mode

Set the optimizer skill to MODE: shadow. The task computes and posts what it would do, but changes nothing.
2

Run once and approve its tools

Trigger a manual run and approve the tools it needs (reads + your channel) so future automatic runs don’t stall on a permission prompt.
3

Watch for about a week

Read the daily summaries. Tune the thresholds in the skill until the proposed moves match what you’d have done by hand.
4

Flip to live

Switch to MODE: live and re-approve the write tools. Start with one portfolio, then add platforms and a read-only digest once you trust it.
Scale by adding campaigns to a task’s scope, not by adding more tasks to the same campaigns. One writer per portfolio keeps the audit trail clean and avoids conflicting changes.

​
Where to go next

Connect Claude Cowork

Connect a Cowork project to your ad accounts.

Agent Skills overview

What skills are, the safety rules, and how to install them.

Core workflows

The exact tool sequences for builds, analysis, and automation.

Always-on on a VPS

Run an agent 24/7 on your own server.
Do I need to write all of this myself? No. Start from Adspirer’s shipped skills and the templates above, then tune. Most teams begin with one build skill and one read-only digest task.What if a scheduled run fires late or gets skipped? That’s expected. Every run reads live state (current budgets and month-to-date spend), so a late run recomputes from where things actually are rather than compounding an old number.How do I stop everything fast? Flip the optimizer skill to MODE: shadow, or pause the task. Both stop all writes immediately while the task keeps reporting.Can one Cowork project manage multiple accounts? Yes — see running multiple agents and accounts. Keep one writer per portfolio so scheduled tasks never collide.
Last modified on June 18, 2026