---
name: blank
description: "Set up the AI Automation Agency company template on naïve for the person you work for: ask its setup questions, install it with the naive CLI or the API, then hand them the approvals."
url: https://usenaive.ai/companies/ai-automation-agency
blueprint: agency
template: blank
---

# AI Automation Agency on naïve

A person asked you, their coding agent, to set up the AI Automation Agency company for them on naïve. Follow this file top to bottom. The whole agency machine with no specialism attached: CRM, public site, a workspace per client, and an agent team that works the pipeline, the content and the site. You bring the trade.

- Page: https://usenaive.ai/companies/ai-automation-agency
- Listing (the source of truth, no key needed): `GET https://api.vetta.sh/v1/blueprints/artifacts/agency/blank`, release 1.4.0. Where it and this file disagree, the listing wins.

## What this template runs

| Part | Name | What it does |
| --- | --- | --- |
| Agent | `site-builder` | Public site. Keeps the public site true to the agency: rewrites hero, services, who-we-serve, process, pricing and FAQ from the… |
| Agent | `sales` | Pipeline. Works the pipeline end to end in the CRM: finds prospects that match the ideal client, adds them as leads with a… |
| Agent | `client-manager` | Delivery. Owns every signed client: runs onboarding, keeps each calendar honest, and flags a stall before the client notices… |
| Agent | `content-writer` | Content. Writes the agency's own blog: one post per slot, each against a named intent and keyword from the editorial calendar… |
| Agent | `content-reviser` | Revisions. Keeps what is already published sharp: finds thin, stale or off-voice pages and posts and files a revision for each… |
| Agent | `gap-researcher` | Research. Compares the agency's site against named competitors: keywords they rank for that you do not, page types you lack… |
| Agent | `proposal-writer` | Proposals. Turns a qualified lead into a proposal: scope, three package tiers from the pricing answer, timeline. Works when sales… |
| App | `dashboard` | fullstack. The agency's public site at / — served from the site profile the team edits — and the operator dashboard under /app: signed clients' workspaces, approvals, agents. The pipeline is the CRM. |
| Mini app | `crm` | CRM |
| Mini app | `calendar` | Calendar |
| Mini app | `ads` | Ads |
| Mini app | `seo-geo` | SEO & GEO |
| Persona | `agency` | The agency itself — the persona its agents read, draft and connect accounts as. |

| Timer | When | Does | Cap per run |
| --- | --- | --- | --- |
| `sales` | `30 8 * * 1-5` America/New_York (every weekday at 08:30) | Inbox and new leads | $10.00 |
| `client-manager` | `0 8 * * 1` America/New_York (every Monday at 08:00) | Client check-in | $10.00 |
| `content-writer` | `0 7 * * 2,4` America/New_York (every Tuesday and Thursday at 07:00) | New blog post | $10.00 |
| `content-reviser` | `0 9 * * 3` America/New_York (every Wednesday at 09:00) | Fix weak pages | $10.00 |
| `gap-researcher` | `0 9 * * 5` America/New_York (every Friday at 09:00) | Competitor gap report | $10.00 |

- Deploys: CRM + site
- Works in: Gmail
- Sends without you: Never

## Cost

- From $20/mo per company, includes 100,000 credits. The person pays the plan in a browser. You never enter payment details, subscribe, top up or upgrade for them.
- Each timer run is capped at the amount in the table above. A run that would pass its cap stops instead of spending.
- `site-builder`'s first session is capped at $20.00.
- `sales`'s first session is capped at $20.00.
- `client-manager`'s first session is capped at $20.00.
- `content-writer`'s first session is capped at $20.00.
- `content-reviser`'s first session is capped at $20.00.
- `gap-researcher`'s first session is capped at $20.00.
- `proposal-writer`'s first session is capped at $20.00.

## Prerequisites

1. A naïve account. If the person has none, send them to https://app.usenaive.ai/register?blueprint=agency&template=blank to sign up, and wait until they say it is done. That page also offers to set this template up in the browser: they can stop once the account exists.
2. A plan, which the person picks and pays in the studio (https://app.usenaive.ai/subscribe), never you. A new company can install first: its install is held until they activate it (see After install).
3. An API key with these six scopes: `agents:read` `agents:write` `sessions:read` `files:read` `files:write` `billing:read`. Why six: the crew needs `agents:read` and `agents:write`. The template's apps get their own key, made from this one, and it needs `sessions:read` `files:read` `files:write` `billing:read`. A key can't give scopes it doesn't have, so without those four the apps and docs are refused.
   The person makes the key in the studio: Settings → API keys → New key (https://app.usenaive.ai/settings), ticking the six scopes. It is shown once. (`naive keys create --name agent --scopes agents:read,agents:write,sessions:read,files:read,files:write,billing:read` also makes one, but only from a CLI signed in with the person's own login, `naive auth login --email`, so normally the person uses the studio.) Have them save it to a file or set `NAIVE_API_KEY` themselves. Never echo, log or commit it.

## First: is it already installed?

Check this before you ask the setup questions. The person may have set it up in the browser already.

```bash
npm i -g @usenaive-sdk/cli
naive --version                         # below 1.1.0 has no `naive install`: use Path B
export NAIVE_API_KEY="$(cat key.txt)"   # a file holding only the key (or the person sets it); it overrides any stored login
naive whoami                            # the organization this key belongs to
naive installs --project ai-automation-agency
```

Without the CLI: `curl -sS "https://api.vetta.sh/v1/blueprints/installs?project=ai-automation-agency" -H "Authorization: Bearer $NAIVE_API_KEY"` (SDK: `client.apps.installs.list({ project: "ai-automation-agency" })`). If it lists a row, the template is installed: skip to After install. If not, go on.

## Setup questions

| key | label | required | type / options | help | example |
| --- | --- | --- | --- | --- | --- |
| `offer` | What does your agency sell, and to whom? | yes | text | One or two sentences. The site-builder writes the hero from this; sales and the writers read it before every session. | Paid social and landing pages for DTC skincare brands doing $1–10M. |
| `ideal_client` | Who is your ideal client — industry, size, geography? | yes | text | Sales builds its first prospect list from this on day one. | US and UK skincare brands, 5–50 staff, running paid social already. |
| `pricing` | How do you price — retainer / project / hourly — and your typical range? | yes | text | Shapes the pricing section of the site and the proposal skeleton. | Monthly retainer, $4k–$12k, three-month minimum. |
| `network` | Who do you already know who might need this, or know someone who does? | no | text | Former colleagues, past employers, friends with businesses: a name, their company and how you know them. Sales drafts a short personal note to each for you to review and send. Leave it blank to skip. | Dana Kim, Brightline Bikes, my old manager at Shopify; Sam Ortiz, Ortiz Dental, college friend. |

Ask these after checking it isn't already installed (above). Ask the person for every required answer you do not already know, in one message. Never invent an answer. If an answer doesn't cover what the question's help asks for, ask once more; if they still don't have it, use what they gave and tell them they can change it later (After install). Offer the optional ones once and leave them out if they have none. A list answer repeats its key.

## Path A: the naive CLI

```bash
naive install agency blank --project ai-automation-agency --answer 'offer=<answer>' --answer 'ideal_client=<answer>' --answer 'pricing=<answer>' --dry-run
naive install agency blank --project ai-automation-agency --answer 'offer=<answer>' --answer 'ideal_client=<answer>' --answer 'pricing=<answer>' --new
naive installs --project ai-automation-agency
```

1. The dry run writes nothing. It lists the named agents, apps and identity (persona) the install would create. The real run also arms the template's schedules and writes its docs; the preview doesn't show those. Tell the person all of that, and get a yes before the real run, which starts agents that spend credits.
2. `--new` refuses a project that already exists instead of changing it. Add `--new` to the dry run too and it tells you before the real run. Then read the result (below).
3. To leave a part out: `--without a,b` (or `--only a,b`): comma-separated, or the flag repeated. Optional here: `site-builder`, `sales`, `client-manager`, `content-writer`, `content-reviser`, `gap-researcher`, `proposal-writer`.
- Each answer is `--answer 'key=value'`; a list answer repeats the flag. Leave out an optional question the person has no answer for.
- Advanced: `VETTA_API_BASE_URL` overrides the API host (default https://api.vetta.sh).

## Path B: the SDK or HTTP

```ts
import { createClient } from "@usenaive-sdk/managed-agents";
const client = createClient({ apiKey: process.env.NAIVE_API_KEY! });
await client.apps.installs.preview({ blueprint: "agency", template: "blank", project: "ai-automation-agency" }); // the dry run: writes nothing, see Path A note 1
const install = await client.apps.installs.apply({ project: "ai-automation-agency", blueprint: "agency", template: "blank", answers: { "offer": "<answer>", "ideal_client": "<answer>", "pricing": "<answer>" }, expected_revision: 0 });
```

```bash
curl -sS -X POST https://api.vetta.sh/v1/blueprints/installs \
  -H "Authorization: Bearer $NAIVE_API_KEY" -H "Content-Type: application/json" -H "Idempotency-Key: $(uuidgen)" \
  -d '{"project":"ai-automation-agency","blueprint":"agency","template":"blank","answers":{"offer":"<answer>","ideal_client":"<answer>","pricing":"<answer>"},"expected_revision":0}'
```

As in Path A: check it isn't installed (above) before the questions, and tell the person what the preview leaves out (schedules, docs) before the apply. An error comes back as `error.code` and its message.

## Reading the result

- `status`: `applied` (created; read `failure` and the exit code, a partial apply is still `applied`), `pending` (still finishing on the server: watch `naive installs --project ai-automation-agency`), `held` (waits for the person, see After install), `failed` (`failure` says why).
- Exit 0: everything was created.
- Exit 1: an API refusal, or a partial apply. An `applied` row with refusals (`failure`, or `report` lines with `action: "refused"`) means the company exists but the refused parts don't. Read `next` and `report`, tell the person exactly what was refused, and don't retry blindly. A refusal about missing scopes means a new key with the six scopes (Prerequisite 3). A refusal that names something the platform must set up (such as "not configured") means the person contacts support: they can't fix it themselves.
- Exit 2: a usage problem, such as a missing or unknown answer. Ask the person, then retry.
- `next` appears on the install's own response only, not later in `naive installs`, so save it.

## After install

- An install with `status: "held"` is not a failure: the company is still being set up, and its team starts once the person activates it in the studio. The checkout is theirs. Tell them, and do not retry.
- The studio (https://app.usenaive.ai) opens on the CEO's chat. That is where the person talks to the company.
- Nothing goes out on its own: each post or send waits in the studio until the person allows it.
- The person connects the accounts it posts from to the `agency` persona in the studio (Identities).
- To change an answer: `client.apps.installs.update(install.id, { answers })` (`PATCH /v1/blueprints/installs/{id}`) with the whole map, every answer kept. With the CLI: `naive installs context --project ai-automation-agency` prints the answers, and `naive installs context --project ai-automation-agency --set key=value` changes one (no clone needed).

## Rules

- Never post, publish or approve anything for the person. Approvals are theirs.
- Never pay, subscribe, top up or upgrade. Show any checkout link verbatim and stop.
- Never build it around a real person, a brand, or work the person holds no rights to.
- The line it never crosses: No email leaves without you. The agents read your Gmail and draft every reply, but each send waits in Approvals until you tap Allow.
- On any refusal (exit 1, or an `error` from the API), stop. Tell the person exactly what was refused (`error.code` and message, or the `next` and `report` lines) and ask before you try anything else. Only a usage problem (exit 2) is retried, once the person has answered.
