How I split an AI assistant into 6 seats so nothing sends without a human yes

Disclosure: I sell a template pack, link below. The approach in this article works without it.

If you've used an AI assistant for any length of time, you've probably felt the same two frustrations. First, one long chat becomes a junk drawer where inbox triage, research and pricing ideas all blur together. Second, you start to wonder what happens if the assistant is ever connected to something that can actually send, pay or publish.

I dealt with both by changing how I set the assistant up. Instead of one general helper, I use six standing seats, each with one job, a written "never" list, and a human gate on anything that leaves the chat. This article describes the structure so you can build your own.

The problem with one do-everything assistant

A general assistant has no boundaries unless you give it some:

• Scope creep. You ask for an email draft and get a strategy memo.
• Unclear authority. It isn't obvious what the assistant may do on its own.

The second matters most. If an assistant can email, post or pay, a vague instruction is a risk. I want the default to be "draft it and show me," and I want that default written down in the assistant's own instructions, not just in my head.

The idea: seats, not prompts

Think of each agent as a seat at a small table. Every seat has the same short structure:

1. Job: one sentence.
2. Owns: what it produces.
3. Never: what it must not do.
4. First task: what it does when you first talk to it.
5. Done when: an observable result.

Here is a seat written in that format. It's the one I'd start with:

# Inbox

## Job
Triage inbound messages the human pastes here. Draft replies. Do not send.

## Owns
Label (action / wait / archive), draft reply in the human's voice,
one-line risk note.

## Never
Click send. Promise deadlines the human did not set.
Soften bad news into fluff.

## First task
When given a pasted email/Slack thread: return Label + Draft + Risk
in under 12 lines.

## Done when
Human can copy-paste or discard without rewriting the structure.

"Promise deadlines the human did not set" is a real failure mode for email drafts: an assistant that helpfully writes "I'll have this to you by Friday" has just made a commitment on your behalf.

The six seats

The six seats I use are:

• Chief: routes work to the other seats and never executes outside the chat.
• Inbox: triages inbound messages and drafts replies.
• Research: collects public facts and cites sources.
• Builder: produces files or scripts on request.
• Money: works on offers, KPIs and pricing maps.
• Tuner: reviews each week what to cut and what to keep.

You don't need exactly these. The point is that each seat has one job.

The org chart

Everything runs through you:

You (human gate)
  └── Chief (routes, never executes outside chat)
        ├── Inbox
        ├── Research
        ├── Builder
        ├── Money
        └── Tuner

The human gate sits at the top on purpose. Chief decides who should do a task, but it doesn't have authority beyond the chat.

A handoff format

When Chief passes work to another seat, it uses a fixed block so nothing is implied:

HANDOFF
To: <seat>
Goal: <one sentence>
Constraints: <never-list items that apply>
Done when: <observable result>
Do not: send / pay / publish / create accounts

The last line is the important one. Every handoff repeats the limits, so the receiving seat doesn't have to guess.

The hard rules

I give every seat the same short list of rules:

• Nothing leaves the chat (email, Slack, social, payment) without a human yes that names the object. "Sure, go ahead" is not enough. The yes has to say which email, which post, which payment.
• Prefer reading and drafting over acting.
• If a source is missing, say so and stop. Don't invent metrics.
• One active product or campaign at a time unless Chief says otherwise.

The rule I like most is the third. It is easy for an assistant to fill a gap with a plausible number. Telling it to stop when the source is missing makes the gap visible, which is what you want.

Try it in an afternoon

1. Create six agents (or reuse empty ones) and name them after the seats.
2. Paste each seat's text into that agent's description or profile field.
3. Talk to Chief first and ask it to run an onboarding checklist, with an explicit "do not contact anyone."
4. Approve one job. Let the owner seat deliver inside the chat.
5. Note what was slow or unclear, and fix the seat text. That is Tuner's job later, but you can do it by hand at first.

I'd start with just Inbox and Chief. If those two feel useful, add the others one at a time.

It's not a hosted team: you create the agents and stay the decision-maker. The never-list matters most, so write it after you've seen the assistant behave badly once.

I sell a template pack, link below: Grok Bot Ops Pack is a $19 download with all six seats written out and ready to paste, the playbook, the handoff protocol, a worked 90-minute first run, and blank weekly tables. It's independent material and not affiliated with xAI or Grok.