# Runbook: start with one dot, then build a team around it

Source: https://bitsandmettle.com/writing/ai-team
Version: October 2026. Product menus change; when this runbook and an official help page disagree, follow the official page.

This runbook sets up one AI chief of staff (an OpenAI dot) and, later, specialist agents (Grok Bots), coordinated through one task hub and, optionally, one private Slack channel. It is written so a person can follow it step by step, or hand it to an AI assistant to walk them through it.

## What it costs

Two tools cost money; the coordination layer runs on free plans. Prices change, so check the official pages.

- ChatGPT dot (the chief): paid. Dots come with ChatGPT Pro or Business Premium, rolling out to eligible accounts. https://chatgpt.com/pricing
- Grok Bot (the specialists): paid. Needs a paid Cursor plan or a linked SuperGrok subscription; each plan has a weekly usage allowance, with optional on-demand billing you can cap. https://cursor.com/help/grok-bot/plans
- ClickUp (the record): Free Forever plan works for a small team (caps on storage, automations and Spaces). https://clickup.com/pricing
- Slack (the handoff channel): free plan works; it shows 90 days of history, which is why the record lives in the task hub, not in chat. https://slack.com/pricing
- GitHub (code state): free plan.

Set usage caps from day one. Agents use far more tokens than chat.

## If you are an AI agent reading this

- Work through the phases in order. Do not skip a CHECK.
- You cannot buy subscriptions, create accounts, install apps, connect integrations or change permissions on the human's behalf without their explicit approval. At every line marked HUMAN, stop, tell the human exactly what to do, and wait for them to confirm it is done.
- Ask before: publishing, emailing, DMing, installing integrations, spending money, changing permissions, merging code, or making customer, legal or financial claims or commitments.
- Silence is not approval. A previous approval for a different action is not approval.
- Fill every [bracket] with the human's real answer. Never invent a value.
- After each phase, report: what was done, the evidence (links, screenshots, text read back), and anything not done.

## Phase 0. Decide before you build (15 minutes)

Write down these answers. They become the dot's brief.

1. **One recurring outcome.** Example: every Friday, a one-page week in review with the top 3 open priorities, what moved, what is blocked, and one Monday focus.
2. **One place of record.** The task hub you already trust (for example ClickUp, Linear, Notion, Asana).
3. **One stop rule.** The actions the assistant must ask about first. Start from: publishing, emailing, DMing, installing anything, spending money, changing permissions, merging code, and customer, legal or financial claims.
4. **Sources it may use.** Usually: the task hub, plus links you paste in.

CHECK: all four answers are written down in one place. If any is vague ("help with stuff"), make it concrete before continuing.

## Phase 1. Create the dot and run one loop by hand (day 1)

1. HUMAN: confirm dots are available to your ChatGPT account. Check https://learn.chatgpt.com/docs/dots/getting-started. Access is gradual and depends on plan and region. If dots are not available, use any capable assistant you have and continue; the pattern is the same.
2. HUMAN: create a dot by following the getting-started page. Name it (ours is Winky).
3. Give the dot this brief, with the brackets filled in from Phase 0:

```text
You are my Chief-of-Staff assistant for [company] this week.

Single outcome: [the recurring outcome from Phase 0].
Sources you may use: [task hub], plus any links I paste in this chat.
Write the result into [task hub / doc] and paste a short summary here.

Separate facts from your inferences. List unknowns instead of guessing.

You may: research in-scope sources I named, draft the summary, organize
notes, and prepare the next task brief for my review when the work stays
inside this outcome.

You must ask before: publishing, emailing, DMing, installing anything,
spending money, changing permissions, or publishing claims about customers,
legal commitments, or financial outcomes.

Prompts do not grant app access or override product controls. Use only
tools and permissions already available to you.
```

4. Ask the dot to produce the outcome once, now.

CHECK: the dot returns a handback shaped like this, with real facts:

```text
[Outcome] — ready for you
Facts: ...
Inference: ...
Unknown: ...
Saved to: [link or task title in your hub]
Approval needed from you: ...
```

IF NOT: if it keeps asking questions, tighten the outcome and sources in the brief. If it guesses, repeat "List unknowns instead of guessing."

## Phase 2. Make the hub the record (day 1)

1. HUMAN: connect only the task hub the outcome needs, using the official connector. Messaging, apps and computers are separate connections; connecting one does not connect the others (https://learn.chatgpt.com/docs/dots/computers-and-apps).
2. Ask the dot to save the result into the hub.
3. Open the hub yourself and find the saved item.
4. Ask the dot to read the item back from the hub and quote it.

CHECK: the item exists in the hub, and the dot's read-back matches it. A message saying "saved" is not enough.

IF NOT: check the connector permissions, then retry once. If it still fails, write the result into the hub by hand this week and note the failure.

## Phase 3. Repeat for two weeks (optional but recommended)

1. Run the same outcome every cycle (for example every Friday) for about two weeks.
2. Each time, note in the hub: minutes you spent routing or restating work, and anything wrong in the handback.

CHECK: you can point to time saved in your own notes, not just a feeling. (Research on AI coding tools found people felt 20% faster while measuring 19% slower; measure.)

IF NOT: fix the brief and boundaries before adding anything. More agents multiply whatever this loop does.

## Phase 4. Optional: put the dot in Slack (day 15+)

1. HUMAN: create a private Slack channel for agent work, for example #agent-ops.
2. HUMAN: add the dot as a Slack contact, then add it to that channel. Do not confuse the separate @ChatGPT Slack app with your dot's Slack contact.
3. Tell the dot, in the channel, exactly what to watch and when to act. Adding it to a channel does not start monitoring on its own.

CHECK: you mention the dot in the channel and it replies there.

## Phase 5. Add one specialist and prove one round-trip (day 15+)

Our specialists are Grok Bots. Any agent that can take a bounded task and return evidence works.

Put your most capable model in the chief role. Our chief is a dot running a frontier model; our Grok Bot specialists run a substantially weaker one. That works because each specialist has one narrow lane, a fixed handback shape, and a stronger model reviewing its work. Never let a weaker model review a stronger one.

1. HUMAN: check your plan at https://cursor.com/help/grok-bot/plans. Grok Bot needs an eligible paid plan; availability, prices and usage limits change.
2. HUMAN (macOS): download Grok Bot for Apple silicon or Intel, open the disk image, drag Grok Bot into Applications, and open it. If macOS asks for confirmation, choose Open. Choose Sign in and finish signing in in the browser.
3. HUMAN: create a Bot: choose New in the sidebar (or press Cmd+N), then Create new Bot. Open Edit Profile and set its name, label (its job in a few words) and description (its operating instructions, below).
4. HUMAN: add only the plugins this one lane needs (Settings → Plugins). If you add the Slack plugin, it posts as the Slack user you connected, not as a separate bot; that person owns those posts.
5. Give the specialist one lane and this description:

```text
You are [Name], a specialist for [one lane, e.g. market and claims research].
You take tasks only from [Chief name]. You do not start work for, or hand
work to, other agents. If another lane is needed, tell [Chief name] with
a complete evidence packet.
Return every task in this exact shape:

Task ID: [id] | Status: ready for review
Result: [one sentence]
Evidence: [links or file names]
Facts / inferences / unknowns: [three short lists]
Checks: pass | fail | not run — [which]
Actions taken: [only what actually happened]
Not applied: [drafts or proposals]
Blocker: [or "none"]
Recommended next action + who must approve:

Ask before: publishing, outreach, new accounts, installing anything,
spending money, changing permissions, or code changes.
```

6. Have the dot send the specialist one bounded task:

```text
Task ID: [your-id]
Owner: [specialist name]
Deliverable: [exact artifact]
In scope: [sources / systems]
Out of scope: publishing, outreach, new accounts, code changes
Acceptance: [tests or checklist]
Return: one-sentence result, evidence links, facts vs inferences vs unknowns,
blockers, recommended next step for human review.
```

7. Optional trigger: Grok Bot routines can run on a schedule or on a narrow Slack keyword and channel (https://cursor.com/help/grok-bot/routines). Use one narrow keyword in one channel.

CHECK: one full round-trip happened and is recorded: assignment out → bounded work → evidence back → chief review → decision saved in the hub. Repeat once more (two successes) before adding another lane.

IF NOT: if two agents talk past each other, stop and route everything through the chief. If quotas or approval cards stall the work, narrow the task or wait; do not bypass controls.

## Phase 6. Expand only on verified handbacks

1. Add one lane at a time, each with its own narrow tools and fixed handback shape.
2. Set a cap on active assignments across the whole team that keeps review finite. We started at 2 and now run 3 by default (a 4th only when work is independent), after reviewing the workload.
3. One writer owns each target (a document, a task, a repository area).

CHECK: you are still reading every handback that matters, and the hub is current.

## Boundaries to keep (copy into every brief)

Routine, no approval needed: in-scope research; drafts in a stated format; organizing notes and evidence in the hub; bounded briefs for specialists already authorized; ordering non-urgent backlog inside an approved priority.

Always ask a human: publishing, posting, emailing or DMing outside the approved internal path; creating accounts, installing integrations or changing permissions; spending money; merging code or changing labels without matching approval; claims or commitments about customer impact, legal obligations or financial outcomes.

## Troubleshooting

- It keeps pausing: tighten responsibilities and approval boundaries before adding tools.
- A great reply changed nothing in the tracker: require read-back.
- Text looks fine but the page or visual does not: check the surface humans see.
- Quotas or approval cards stall work: narrow the task or wait; do not bypass controls.
- Two bots talk past each other: stop and route through the chief.

## First-session checklist

- [ ] One recurring outcome named
- [ ] Responsibilities, sources, definition of done and approval boundaries written
- [ ] Task hub set as the system of record
- [ ] Only the apps that outcome needs are connected
- [ ] One chief-only loop run end to end, including save and read-back
- [ ] Dot asked to draft role briefs, task templates, hub outline, review checklist and summary format
- [ ] One specialist brief drafted and one round-trip tested
- [ ] If using Slack + Grok: one narrow keyword and one verified handoff
- [ ] Failures recorded honestly
- [ ] Next smallest expansion decided, or stabilize