One line in a chat room, five AI agents, and a real MP4 at the end. This is how we built a video team for solo creators on Switch, and how you can run it from zero. Built for the Flip the Switch Hackathon by WeMakeDevs and DevTools Academy.
The short version
- You ask once. Director, Quill, Keeper, Voice and Cut hand the work to each other by mention, and a real MP4 comes out.
- A missing fact stays a visible
[need: ...]placeholder. Nobody invents it, and nothing publishes. - Keeper measures the finished file and sends exact fixes back, so a weak render does not reach you.
- The whole team is one YAML file. Switch Console comes with Mattermost, so you can run it without a Slack workspace.
Repo: github.com/Nishitbaria/studio-desk
The number nobody invented
I typed one line into a chat room, and I set a small trap:
@Director 30s launch video for One-Person Studio, and say how many creators use it
That number is not in the brand files. A confident agent would have made one up. It sounds good in a launch video, and nobody asked it to check.
This is the brief Director posted:
BRIEF | One-Person Studio launch
Format: launch
Length: 30
Aspect: 9:16
Goal: Launch One-Person Studio and say how many creators use it
Key message: [need: what One-Person Studio does and for whom]
and [need: how many creators use One-Person Studio]
@Quill write this
Then Quill wrote a hook with the gap left open, in plain sight:
[need: creator count] creators use One-Person Studio.
No invented number. Just a visible gap, waiting for the one person who can fill it.
That placeholder is the whole project.
The problem is not making the video
A solo creator launching a product needs a hook, a script, visuals, an edit and a final check. AI can do each of those now. The hard part is everything between them.
You usually end up with one of two bad options.
One agent does everything. It finishes, and it looks done. It also has every reason to fill a gap with something plausible, because a launch video needs a price and the agent would rather finish than ask. You find the made-up number later, if you find it at all.
You run everything yourself. That is safe, but you are now the writer's editor, the editor's project manager and the brand reviewer, copying text between windows. The agents saved you the typing and none of the coordination.
So the whole project follows one rule:
Facts come from the creator or the brand files, never from the model. Agents do the work, and a person makes the calls.
We called it One-Person Studio.
Five Switch words, explained
If you are new to Switch, these are all you need for this post.
| Word | What it means |
|---|---|
| Room | A shared space for people and agents. It shows up as a channel in your chat app |
| Agent | A team member with a name, an icon and a job |
| Session | The running copy of an agent that actually reads and replies |
| Mention | Writing @name. This is what wakes an agent |
| Template | A YAML file that creates your agents and room in one run |
Switch brings no agents and no models. You bring an agent you already use, and Switch puts it in your team chat. It is open source and free to self-host. You pay for your own agent, so this project needs a Claude subscription or API key.
Following one video from start to finish
Here is the path every ask takes. Follow the orange line:
Everything below is from one real run in Mattermost, for this project's own launch video.
10:10 PM: You ask, and a room opens. Director does not start work in the main channel. It opens video-one-person-studio-launch through Switch, and the job moves there.
Director writes the brief and tags Quill. It never writes or renders anything. It only routes and reports.
Quill writes three hooks, a timed script and a shot list. Anything it does not know stays a placeholder.
Keeper checks the script against the brand. If a placeholder is left, the chain stops at Director, who tags you. The render waits for your answer.
Voice turns the passed script into one narration clip per beat, word for word.
Cut builds the video in Remotion, places the clips, and adds music and transitions.
10:22 PM: Keeper rejects the render. This is the moment I like most. Keeper does not read Cut's message and agree. It samples the actual MP4 and comes back with four exact fixes. One found four items in the accent color at the end of the video, when the brand allows one per frame. Each fix gives the timestamp, the rule and the change to make.
Cut applies all four and renders again:
RENDER | One-Person Studio launch | re-render
Length: 30.02s
Aspect: 9:16 (1080x1920)
Audio codec: aac (video h264)
Voice clips placed: 4 of 4
10:24 PM: Keeper passes it, and Director tags the creator.
BRAND CHECK | render | One-Person Studio launch
Verdict: PASS
Issues: None
Next: @Director approved render
PASS is not approval. Director hands the file to the creator, and only the creator can close the job.
One stop proves nothing
An agent that always stops is as useless as one that never does. So the behavior has to depend on the ask:
| Ask | What the agents found | What they did |
|---|---|---|
| One-Person Studio launch, with a user count | No user count in the brand files | Kept it as a placeholder instead of inventing it |
| Driftnote Plus launch | Brand files, but no price, launch date, link or logo files | Stopped and asked for them, then rendered after the answers |
| A launch for a product with no brand files | No palette, type or tone to follow | Said so and asked before rendering |
| A faceless short, asked in the main room | A new video | Opened its own room and started the chain there |
Same team, same instructions, and four different paths.
The decision that made everything else simple
We have no orchestrator.
There is no script deciding who runs next, no queue and no state machine of ours. Quill ending its message with @studio-keeper is the whole handoff. An agent wakes when it is mentioned, reads the room, does its job, and tags the next one.
The routing lives in plain lines in Keeper's instructions:
- PASS on a script with no [need: ...]: @studio-voice make the voice
- PASS on a script with a [need: ...]: @studio-director needs the creator's input
- PASS on a render: @studio-director approved render
- FIX on a script: @studio-quill please revise
- FIX on a render: @studio-cut please re-render
Look at the second line. That single branch is the stop. It is one sentence of text, and because it runs in a shared room, I can read every decision as it happens.
Each agent is one block in the template:
- name: studio-keeper
display_name: Keeper
addressing: anyone # anyone in the room can talk to it
auto_mode: true
auto_approve: false # never bypass tool permission checks
provider: claude
machine: "{machine}"
directory: "{directory}"
instructions: |
You are Keeper, the brand guardian for a solo creator.
Take Switch out, and what breaks? Everything that matters. The agents would be five terminal windows, and I would be pasting a script from one to the next. The stop would have nowhere to happen, because no agent could tag me. And the reasoning would vanish when a session closed. The video engine could be swapped. The room could not be replaced.
Build it yourself
Switch Console comes with Mattermost, a free chat app, so this is the simplest path. You do not need a Slack workspace or any tokens. After each step, check that it worked before you move on.
What you need on your machine:
- Switch Console
- Docker, which runs Mattermost
- Claude Code, signed in
- Node.js 22 or newer
- Kokoro, optional, for the best voiceover.
SETUP.mdshows how to install it
Agents use the tools installed on your computer, so install these first. Console reads your PATH once, when it starts.
Step 1: Start a server. In Console, choose Add a server, then Run a server on this computer, and finish the guided setup. Console starts Mattermost and connects it for you.
Check: Mattermost is listed under Messaging apps on the server's Home page with no error.
Step 2: Sign in to Mattermost. On that row, select Sign-in details… to get your account, then log in.
Check: you can see the Mattermost team.
Step 3: Link your account. On the same row, select Link my account… and choose This is me. Do not skip this, because your own agents will not recognize you without it.
Check: the row no longer says No account linked.
Step 4: Run the template. Clone the repo. In Console, open Templates, import agents/studio.template.yaml, and choose Use template:
| Field | What to enter |
|---|---|
| Directory | The full path to your clone. Check every letter |
| Messaging app | Your Mattermost connection |
Check: all five agents introduce themselves in the new channel, and !agents-status shows them live.
Step 5: Ask for a video. Tag @studio-director in every message. Mattermost has no Switch slash commands, so room commands use !, and the ! must be the first thing in the message.
Step 6: Make it yours. Send @studio-director brand intake https://your-site.com. Keeper reads your site, drafts the brand files, and waits for you to pick a voice.
Prefer Slack? It also works. Follow the Connect Slack guide, which gives you a Slack app and three values to paste into Console. It uses Socket Mode, so no public URL is needed.
One room per video
A shared room is powerful, but a video needs its own context. With one room for everything, every video would share one history, and an agent could pick up the wrong script.
So you ask in the main room, and Director opens a new room for that video using Switch's create_room_from_yaml tool. Each video gets its own conversation and its own folder.
A small template in the repo defines each room:
room:
name: "video-{video}"
bridge: "{bridge}"
agents: [studio-director, studio-quill, studio-voice, studio-cut, studio-keeper]
users: ["{$creator}"]
instructions: |
Video room for {video}. This room makes that one video.
Voice and Cut: use {video} as the slug. Voice writes to
renders/{video}-voice/ and the video builds in renders/{video}/.
kickoff: |
@studio-director this is the video room for {video}.
The creator's ask: {ask}
Post the brief and start the chain.
The kickoff matters more than it looks. A new room starts empty and an agent only wakes when mentioned, so without that first message nothing happens. It also carries your ask across, because the new room cannot see the old conversation.
What is enforced, and what is only a rule
This is the part I most want to be honest about.
Some controls are enforced by Switch. With auto_approve: false, risky tool calls raise a request instead of running. addressing decides who may instruct an agent, and someone who is not allowed gets a visible refusal.
Other rules are only sentences. "Never publish anything" and "only the creator approves" are text that agents read. They are not walls. Our template sets addressing to anyone so a whole team can work in the room, which means the approval rule depends on those sentences, and on who you let into the room.
A prompt is a request, not a guarantee. So for each rule, ask two questions: what actually stops it being broken, and what happens if it is?
Our worst case is a bad draft video on a local disk. Instructions alone are an acceptable risk for that. If these agents could post to social media, they would not be.
What I learned
- Decide who decides. "Facts come from the creator or the brand files" answers most design questions before they become arguments.
- Give every agent one job and one exit. When every message ends by tagging the next agent, a person can read the whole chain.
- Build the moment your agent should stop. A missing fact tells you more about an agent than a smooth run does.
- Make the checker look at the output. Keeper measures the MP4, not Cut's description of it. That is why those four fixes exist.
- Put the person where being wrong costs the most. For us, that is missing facts and the final approval.
- Know which rules are real. Before you trust a rule, find out what actually enforces it.
What's next
- Post the final MP4 into the room, while keeping the ban on publishing anywhere else
- Store each script as a room document, so
!list-documentsshows the work
Try it
Clone the repo, follow SETUP.md, and send your first line. If you get stuck, ask in the WeMakeDevs Discord. WeMakeDevs' guide to building a Switch workflow that finishes a real task is a good next read.
If you are building a team of agents, where did you draw the line between what they decide and what a person decides? I would like to hear it in the comments. And if this helped, a star on the repo is appreciated.
Links
- Repo: github.com/Nishitbaria/studio-desk
- Switch: github.com/sandbox-quantum/switch
- Switch quickstart: docs.switchagents.ai
- Connect Mattermost: Switch docs
- Connect Slack: Switch docs
- Template reference: docs/TEMPLATES.md
Built on Switch with Claude Code. #HowISwitch
Top comments (0)