Agency OS: White-Label AI Operations Platform for Agencies

Most agencies run AI in the cracks between tools. ChatGPT writes first drafts, Notion AI sits on the side, and Lindy or n8n runs an automation or two. The real process lives in the heads of two senior people and in spreadsheets nobody updates.

Agency OS is the platform I built to fix that. It gives an agency one deployable app that is theirs: their brand, their playbooks and their data. It runs the recurring client work on a schedule, with an account manager approving every output.

What is Agency OS?

Agency OS is an agency operating system: one white-label app that runs an agency’s recurring client work. It has three parts:

1. A brand layer

Every visual and editorial decision in the app reads from a single branding.json file at boot. Palette, fonts, logo, favicon, OG image, app name, login copy, tone of voice, banned phrases, signature style. Drop in your file, restart, and every page and every email carries the agency’s brand.

For a luxury PR agency that might mean a cream and gold palette with EB Garamond headings, in a restrained editorial voice. A performance-marketing shop would choose a louder palette and tighter copy. The code stays the same; only the file changes.

The voice tokens (voice.tone, voice.bannedPhrases, voice.signatureStyle) are read by the AI agents at runtime, so the drafts the platform produces sound like the agency.

2. The loops primitive

A loop is a workflow that runs on a cadence, has a human approval gate, and captures learning. That last part matters, because each run feeds what it learned into the next.

Concretely:

• Inputs (collectors): structured pulls from GA4, HubSpot, Slack, Gmail, Gong, review sources, competitor pages, etc. Per-agency configurable.
• Agents: chained LLM calls in named roles (analytics, narrative and QA) that turn raw inputs into a draft.
• Human gate: account manager edits and approves before anything ships. Always. No silent send.
• Outputs: branded email, Slack post, Notion doc, or Google Sheet update.
• Learning: what worked, what didn’t and what was missing, saved into loop_learnings and fed into the next run’s prompt.

The account manager edits instead of writing from scratch. The agency keeps its taste and the AI does the prep.

3. The skills directory

Each agency’s playbook lives in /skills/<agency>/*.md as plain markdown files with YAML frontmatter. One file is one workflow, so adding a workflow means editing one file, with no code change and no deploy. The runner picks it up on the next loop tick.

A skill file looks like this:

---
name: weekly-client-narrative
description: Synthesise last week's perf into a client-ready narrative
inputs:
  - { kind: ga4, required: true }
  - { kind: hubspot_pipeline, required: false }
  - { kind: slack_threads, required: false }
agents:
  - { role: analytics, model_slot: extraction }
  - { role: narrative, model_slot: workflow_default }
  - { role: qa, model_slot: auto_title }
human_gate: required
outputs:
  - { kind: email_draft, template: client_narrative }
learning_kinds: [winner, loser, gap]
---

# Weekly Client Narrative

## When to use
Every Monday morning, summarise the prior week for each active client.

## What good output looks like
- Opens with the single most important change ('Bookings up 18% WoW')
- Names the cause if known, names the unknown if not
- One decision the client needs to make this week
- Two paragraphs max

## What needs human approval
Always. Account manager edits the draft, then approves.

## What gets saved as learning
- Which framings the client engaged with (replied to, forwarded)
- Which framings they ignored
- Recurring objections or questions

That’s the entire workflow definition. Prompt, role mix, inputs, outputs and learning hooks all live in one version-controlled file. Anyone on the agency team who can use Git or a markdown editor can change it.

The two loops that ship in v1

Loop A: Client Narrative

Every Monday at 8:00, for every active client, the platform pulls the prior week’s GA4 metrics, HubSpot pipeline, and Slack threads. The analytics agent flags anomalies against a four-week baseline, and the narrative agent turns them into two short paragraphs in the agency’s editorial voice. The QA agent checks every claim has data backing it.

The draft lands in the AM’s inbox by 8:30. They edit, approve, and the platform sends a branded email to the client with the agency’s logo, palette, and signature.

The account manager’s weekly update becomes an edit of a draft that is already written, for every client on the roster.

Loop B: Raw Materials

Continuously updates a per-client knowledge base from sales calls (Gong/Fathom), support emails, public reviews, and competitor pages. Three agents extract pain, language, objections, proof, and competitor claims into structured records, dedupe near-duplicates, and maintain a living ‘raw materials brief’ per client.

That brief feeds every other loop. Ad copy, email sequences, sales decks and content briefs all start from the same record of what customers said.

How it deploys

This is where most ‘AI for agencies’ pitches break.

Agency OS is a single-tenant deployment. Each agency gets its own server (or a shared box with isolated directories), subdomain, SQLite database, branding.json and Anthropic billing. I provision the first version, and the agency owns the keys after that.

Why this shape:

• Data sovereignty. Client data lives on the agency’s box, not in a SaaS vendor’s shared DB. Clients in regulated industries often ask for exactly that.
• No vendor lock-in for the agency. The branding, the skills and the data are all portable. If the agency wants to bring it in-house in year two, the migration is moving a directory.
• Anthropic billing on the agency’s account. The agency controls spend and owns the usage history. I don’t mark up tokens.
• Scales by adding deploys, not by re-architecting. Multi-tenancy gets built when paying agencies ask for shared resources.

The architecture, briefly

For the technically curious. Skip if you don’t care.

• Backend: Express + better-sqlite3 + TypeScript ESM
• Frontend: Vite + React 19 + Tailwind v4
• Database: SQLite (one per deploy, encrypted at rest)
• LLM: Anthropic Claude (OAuth via Claude CLI subprocess, or direct API key) + Gemini for image generation
• Schedule: node-cron v4
• Encryption: AES-256-GCM, master key from APP_SECRET
• Hosting: a small Hetzner server per agency, with Caddy and systemd. Nightly backups go to a separate bucket.

Three pluggable registries are the ‘OS’ part: collectorRegistry (data sources), agentRegistry (LLM roles), delivererRegistry (outputs). Adding a new collector is one file in the registry; the loop runner doesn’t change.

Who it’s for (and who it isn’t)

Good fit:

• Agencies of 5 to 50 people running at least 10 active client accounts.
• Account managers spending hours per week on report-writing, client updates, or research that follows the same shape every time.
• Agencies with a real point of view on how their work should be done. It can live in SOPs, style guides or senior people’s heads.
• Agencies who want to look like a platform to their clients without becoming a SaaS company.

Bad fit:

• Solo operators. A setup fee plus a monthly fee is overkill for one person, so a stack of off-the-shelf tools fits better.
• Agencies with fewer than 10 active clients. The loops pay off with volume, and below that the gain is small.
• Agencies that haven’t written down any playbook. With no agency view to encode, the platform only produces generic AI output with a logo on it.
• Anyone wanting a self-serve sign-up. I onboard each early customer by hand, on purpose.

The bigger pattern (this is for SMB readers)

Most readers of this blog run companies of 10 to 500 people and are weighing up custom AI. Agency OS isn’t built for you directly, but its shape is the shape custom AI takes when it’s done well for any business.

1. It’s yours. Your brand on the surface, your data in the database, your billing on the API. Nothing is rented from a SaaS vendor.
2. It encodes your playbook. Your tone, your decisions and your edge cases sit in markdown files anyone on the team can edit.
3. Humans stay in the loop where it matters. The AI does the prep and your team makes the judgement calls. Nothing goes to a client without a person approving it.
4. It compounds. Every run captures what worked and what didn’t, so the next run starts better informed. A shared SaaS tool gives every customer the same model.
5. It deploys to a box you can move. No lock-in. Taking it in-house in year two means moving a directory.

Agency OS happens to be for agencies. I build the same architecture (brand layer, custom workflows, human-gated loops and learning capture) for firms in finance, real estate, e-commerce and the trades. The loop names change to ‘daily AP review’ or ‘listing assistant’, and the shape stays the same.

What’s on the roadmap

Locked in v1: brand layer, loops primitive, skills directory, two shipped loops (Client Narrative + Raw Materials).

Backlog, not in v1, in priority order:

1. Conversion loop: needs analytics, CRM and form-tracking integrations.
2. Sales enablement loop: needs deeper Gong, Fathom and CRM coverage.
3. Creative testing loop: ad account integrations (Meta Ads and Google Ads).
4. Demand capture loop: SEO data from Search Console, plus the Ahrefs or Semrush API as an option.
5. Learning meta-loop: pattern mining across loops, such as a library of winning hooks. Worth building once several live loops produce signal.
6. Multi-tenant SaaS: only once enough paying agencies run on single deployments.
7. Skills marketplace: agencies share or sell SKILL.md files. Far future.

The pattern: ship the primitives, prove them with two real loops, then add domain-specific loops as paying customers ask. I’d rather have one agency relying on the Client Narrative loop than five agencies half-using ten loops.

Pricing and how to start

I don’t publish a price list for Agency OS. The work depends on how many loops you start with and how codified your playbook already is. Setup and the monthly fee are both fixed prices, quoted after a short scoping chat, so you know the full cost up front.

Setup covers brand config from your existing brand book, deploy on your subdomain, the first two loops authored from your SOPs, and AM training.

Monthly covers hosting, ongoing skill iteration, monitoring, support. Anthropic usage is on your own billing, and I don’t mark up tokens.

What you provide: a subdomain you control, an Anthropic API key (or Claude Max OAuth) and an initial conversation about your existing SOPs. That conversation becomes the seed for your first two SKILL.md files.

What you get first: a deployed, branded instance at your subdomain, with your first loop running on test data. Then production data, account manager training and a fixed weekly cadence, followed by ongoing changes based on what the loop is teaching you.

The default brand is an editorial-luxury preset (cream and gold, with serif type). Your own brand book replaces it during setup.

Why I built Agency OS

Two reasons.

One: I have built versions of this for my own business and for clients several times. Each time the same architecture came back: brand layer, scheduled loops, human approval and learning capture. So I made it a product.

Two: the agencies I talk to are stuck between SaaS built for the average customer and an in-house build they can’t staff. Agency OS sits between the two. It is opinionated enough to be useful from the first week and flexible enough to encode the agency’s own point of view.

If you run an agency and this sounds like your problem, tell me about your recurring client work. On a short call I’ll show you whether Agency OS is the right shape for it.

If you run a business rather than an agency, I build this same architecture for firms like yours with different vocabulary. Talk to me if you want one.

Mark