---
name: product-design
description: "Set up the AI Product Design 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/product-design-agency
blueprint: agency
template: product-design
---

# AI Product Design Agency on naïve

A person asked you, their coding agent, to set up the AI Product Design Agency company for them on naïve. Follow this file top to bottom. Designs physical products from a studio brief: a concept mesh for the look, studio stills, and dimensioned parts when the brief names sizes. You approve every file that leaves.

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

## What this template runs

| Part | Name | What it does |
| --- | --- | --- |
| Agent | `account-manager` | Studio lead. Runs the studio: writes the studio note from your four answers on day one, then reads every brief against it and routes… |
| Agent | `designer` | Concept meshes. Turns a look brief into one textured 3D concept mesh. Hands the mesh to the visualizer for a studio still; it never… |
| Agent | `engineer` | Dimensioned parts. Builds a part to the millimetres a brief names, checks it is a watertight solid of the right size, and files STEP and… |
| Agent | `visualizer` | Stills & video. Makes one studio still for each look and files the mesh and still together for your approval. Makes a product video… |
| 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 |
| --- | --- | --- | --- |
| `account-manager` | `0 9 * * 1` America/New_York (every Monday at 09:00) | Studio check-in | $5.00 |

- Team: 4 agents
- A generated mesh: A look, not a drawing
- Files leave: Only after you approve

## 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.
- `account-manager`'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=product-design 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 product-design-agency
```

Without the CLI: `curl -sS "https://api.vetta.sh/v1/blueprints/installs?project=product-design-agency" -H "Authorization: Bearer $NAIVE_API_KEY"` (SDK: `client.apps.installs.list({ project: "product-design-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 |
| --- | --- | --- | --- | --- | --- |
| `products` | What physical products does this studio design? | yes | text | The account manager writes it into the studio note on day one, and the designer's first look is one of these. | Kitchen and desk objects: carafes, lamps, small brackets. |
| `audience` | Who is the work for? | yes | text | The account manager reads every brief against it; the visualizer styles stills for these buyers. | Independent homeware brands. |
| `manufacturable` | Which materials, sizes and features must be manufacturable, and which are looks only? | yes | text | Decides which seat a brief goes to: the engineer builds parts to millimetres, the designer makes looks with no units. | Brackets and mounts to millimetre tolerances; carafes and lamps are looks only. |
| `done` | What does done mean for a typical brief — a concept mesh, studio renders, dimensioned parts, or a short product video? | yes | text | The account manager writes it into the studio note; the visualizer makes a product video only when this or the brief asks. | A concept mesh and one studio still; a dimensioned part when the brief gives millimetres. |

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 product-design --project product-design-agency --answer 'products=<answer>' --answer 'audience=<answer>' --answer 'manufacturable=<answer>' --answer 'done=<answer>' --dry-run
naive install agency product-design --project product-design-agency --answer 'products=<answer>' --answer 'audience=<answer>' --answer 'manufacturable=<answer>' --answer 'done=<answer>' --new
naive installs --project product-design-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: `account-manager`, `designer`, `engineer`, `visualizer`.
- 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: "product-design", project: "product-design-agency" }); // the dry run: writes nothing, see Path A note 1
const install = await client.apps.installs.apply({ project: "product-design-agency", blueprint: "agency", template: "product-design", answers: { "products": "<answer>", "audience": "<answer>", "manufacturable": "<answer>", "done": "<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":"product-design-agency","blueprint":"agency","template":"product-design","answers":{"products":"<answer>","audience":"<answer>","manufacturable":"<answer>","done":"<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 product-design-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 product-design-agency` prints the answers, and `naive installs context --project product-design-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.
- A mesh is not a drawing: A model made from a description has no units. The handoff says so. A part that must be manufactured is a separate file, built from the millimetres the brief names, and it is not offered as a substitute for the mesh.
- 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.
