---
name: would-you-choose
description: "Set up the AI Would You Choose Channel 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-media-channel/would-you-choose
blueprint: media
template: would-you-choose
---

# AI Would You Choose Channel on naïve

A person asked you, their coding agent, to set up the AI Would You Choose Channel company for them on naïve. Follow this file top to bottom. AI Would You Choose Channel is a template that builds an agent team that manages an entire social media account for you, producing "which one would you choose" videos of absurd options. This lets you create the would-you-choose videos that are going really viral right now.

- Page: https://usenaive.ai/companies/ai-media-channel/would-you-choose
- Listing (the source of truth, no key needed): `GET https://api.vetta.sh/v1/blueprints/artifacts/media/would-you-choose`, release 3.5.0. Where it and this file disagree, the listing wins.

## What this template runs

| Part | Name | What it does |
| --- | --- | --- |
| Agent | `channel-manager` (required) | Channel lead. Runs the channel: publishes each finished piece on the cadence you chose — every post waits for your approval — and… |
| Agent | `producer` | Video production. Makes each planned scene as an image, animates it into video, edits the scenes into one finished vertical piece, and… |
| Agent | `trend-scout` | Trends & briefs. Finds what is moving in the channel's niche and starts each piece as a Plan card, with real videos to learn from. |
| Agent | `scriptwriter` | Hooks & scripts. Turns every brief into a sourced scene plan—image prompts, animation prompts, exact dialogue and edit… |
| Agent | `analyst` | Performance. Records every post's numbers daily and reports weekly, per hook and format, on what to make more and less of. |
| App | `media-manager` | fullstack. The channel's posts and numbers: what waits on you, what is scheduled, and what went out. |
| Persona | `channel` | The channel itself — the persona its agents post, read and connect accounts as. |

| Timer | When | Does | Cap per run |
| --- | --- | --- | --- |
| `trend-scout` | `0 6 * * 1,4` America/New_York (every Monday and Thursday at 06:00) | Plan the next pieces | $10.00 |
| `analyst` | `30 7 * * 1` America/New_York (every Monday at 07:30) | Weekly report | $10.00 |
| `analyst` | `5 9 * * *` America/New_York (every day at 09:05) | Performance analysis | $2.00 |

- Each video: 15–18s, 9:16
- Posts to: TikTok, Reels, Shorts
- Posts 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.

## Prerequisites

1. A naïve account. If the person has none, send them to https://app.usenaive.ai/register?blueprint=media&template=would-you-choose 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 would-you-choose
```

Without the CLI: `curl -sS "https://api.vetta.sh/v1/blueprints/installs?project=would-you-choose" -H "Authorization: Bearer $NAIVE_API_KEY"` (SDK: `client.apps.installs.list({ project: "would-you-choose" })`). 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 |
| --- | --- | --- | --- | --- | --- |
| `cadence` | Posting cadence | yes | one of: daily · 3× a week · weekly |  |  |

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 media would-you-choose --project would-you-choose --answer 'cadence=<answer>' --dry-run
naive install media would-you-choose --project would-you-choose --answer 'cadence=<answer>' --new
naive installs --project would-you-choose
```

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 and starter board tasks, and adds a CEO (who owns the board) if the company doesn't have one yet; 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: `producer`, `trend-scout`, `scriptwriter`, `analyst`, `media-manager`.
- 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: "media", template: "would-you-choose", project: "would-you-choose" }); // the dry run: writes nothing, see Path A note 1
const install = await client.apps.installs.apply({ project: "would-you-choose", blueprint: "media", template: "would-you-choose", answers: { "cadence": "<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":"would-you-choose","blueprint":"media","template":"would-you-choose","answers":{"cadence":"<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 (the CEO, starter board tasks, 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 would-you-choose`), `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 `channel` 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 would-you-choose` prints the answers, and `naive installs context --project would-you-choose --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.
- Rules that never bend: No people appear in the frame, no real brand's product or packaging is shown, and no real song is used. No video is presented as real.
- 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.
