How to build your team of AI agents

by the end of this article you'll have a full build to run a team of AI agents with the best models, so your business runs on autopilot and you're only involved to monitor...

here's what you're getting:

• Grok Bot running content, from morning X research to AI UGC ads

• Claude Code running writing and marketing, from the SEO loop to signal outbound

• DeepSeek in pi.dev building everything, on whichever open model is the most efficient that week

• one shared brain and one shared memory for the whole team

• agents working on the same project at the same time without overwriting each other

• Viktor as your chief of staff in Slack, the one you talk to, passing work between the team while your laptop is off

right now you pay for three or four AI tools and you're still the one carrying every task between them

because none of those tools can talk to each other, so you copy the research out of one chat, paste it into another, copy the draft back out and paste it into a third

and every one of them starts from zero, with no idea what you sell, who buys it, how you write, or what the other tool just did

you've become the copy-paste layer of your own business, and that's the job i want to take off your plate

the fix is a team: every member gets ONE job, they all read from one shared brain, and they have a way to talk to each other without you standing in the middle

i run this setup myself, with Viktor as chief of staff and Grok Bot, Claude Code and DeepSeek working under him as one team, and everything below is how to build yours

if you just want it running with a single tool and zero building, the next section is your fastest path, and if you want your own team, keep reading after it

the fastest path: hire Viktor

if you'd rather skip the building entirely, hire Viktor

Viktor is an AI employee who joins your Slack or Microsoft Teams like a new colleague, so you message him in a channel the same way you'd message a person

he does the work and comes back with the finished thing, a sheet, a doc, a draft or a report

everything runs through one tool, which is why this path is the fastest

you connect each tool once (most take one click, and he connects to 9,800+ tools), you ask in normal sentences, and a weekly job you set once keeps repeating

here are the first channels i'd create, with the one tool to connect in each and the weekly job to give him:

• #outreach + Apollo.io: a weekly list of verified prospects, first lines drafted

• #finance + Stripe: a weekly reconciliation of payments, anything odd flagged for you

• #ads + Meta Ads: a weekly performance report per campaign, changes proposed

• #seo + Google Search Console: a weekly read of rankings and site health

• #numbers + PostHog: a weekly summary of signups and product usage

• #research + Apify: a weekly scrape of competitor sites into one sheet

then pin one message at the top of each channel that says what you sell, who buys, what this channel delivers, and what never goes out without you

that pinned message is his whole briefing, so write it like you're onboarding a new hire who's smart but knows nothing about you yet

a weekly job can be one sentence, like this one for #outreach:

every monday, pull the companies in Apollo that fit the buyer in the pinned message, verify the contacts, and post the top rows here with a first line drafted for each... drafts only, nothing sends until i say so

then set the permission per tool, so he reads and drafts on his own and asks before anything sends or spends

he proposes, you approve, and nothing goes out until someone on your side says yes

and because he lives in the channel, your whole team sees his work and anyone on the team can hand him a job

one hire, six channels, and someone working every vertical of your business

the rest of this article is for you if you want to build your own team, piece by piece, where you pick every member and every tool

Grok Bot runs content

Grok Bot is the easiest member of the team to set up, so it's the one i'd start with

it lives on its own cloud computer with a browser, files and a terminal, which means the work keeps going while your laptop is closed

and it reads X directly: it can search posts, read a timeline, check mentions and pull together what's happening in your niche

the rule i learned the hard way: one bot per workflow

when you stack every job into one agent, the context, the memory and the tool calls all degrade together

so each bot carries only its own lane, calls only the tools that lane needs, and remembers only what that lane taught it

xAI's own docs land on the same rule, one durable Bot per distinct job, and the payoff is that you open the app and see where every lane stands, like reading a team dashboard

setting one up follows the same shape every time: give the Bot one primary job, then tell it the outcome, the sources, the constraints, the deliverable and where it has to stop for your approval

run the task once, save the method as a skill when it works, then turn it into a routine on a schedule

here are the content bots i'd run:

1. morning X research

every morning it researches what performed on X in the last 14 days around your niche, real posts with real engagement, notes each winner's angle, and files the findings in your vault

read-only, zero risk, and every other lane on the team feeds from it

1. AI UGC with fal.ai

UGC is those videos of a regular person talking about a product, and this is my favorite lane on the whole team

fal.ai hosts the big video and image models behind one API key, Kling, Seedance, Veo and more, and Grok Bot connects to it directly, so the bot drives the generation while you direct

the prompt to wire it up is short:

connect yourself to fal.ai through their MCP server, sign in with my account, and confirm you can list the video models before running anything

then the pass that separates a real ad from AI slop:

• research winning ads in TikTok Creative Center and the Meta Ad Library

• file every winner in the vault: hook, beat order, who's on camera

• script at three and a half words per second, about 105 words for 30 seconds

• build a character sheet, one close-up and one full-body shot

• the person can hold the product but never change it

• render the hook clip first, approve the face and the voice

• generate the remaining clips on fal.ai from the same images

• stitch everything and pull frames for a final continuity check

then you decide whether the ad sells

the hook-first order is a money rule too, because fal can still charge for a request that fails once GPU time was spent, so you approve the face before paying for every other clip

two things you can't skip: a fake person praising your product can count as a fake review, and you mark AI content as AI wherever Meta and Google ask you to

1. competitor watch overnight

a bot reads your competitors' sites with Firecrawl overnight and leaves a short note in the vault on what changed, with the link where it saw each change

1. posts drafted to Typefully

the X connection is an input path, it reads X but doesn't post, so publishing needs a separate layer, and for me that's Typefully

a social bot drafts from the morning research, so every post starts from an angle that already performed, then parks each draft in Typefully waiting for your ok

and you follow X's automation rules: no copy-pasting one post across accounts, no bot replies to strangers, no automated likes or follows

the bot drafts, you publish, and your voice stays yours

Claude Code runs writing and marketing

Claude Code is the writer on my team, and the rule it lives by is research before writing

if you ask an AI for a post with nothing else, it hands you the average of everything it ever read, and the average of everything is boring

so every writing job starts with evidence

scrapers pull the best accounts and posts in full, with their engagement, and i run mine through Apify

videos get turned into text, captions first and AI transcription only when no caption exists

and every claim in a draft carries the source it came from, so the second you ask where something came from, the receipt is right there

here's what i hand it:

1. YouTube long-form

it scrapes titles, thumbnails and transcripts from a list of competitors and files every video as a note in the vault, with the hook and how it's built

then it checks every day which topics are trending in your niche and writes scripts from that pile of real examples

the upload goes in as private, so the video sits on your channel waiting for you to check it before anyone sees it

1. landing page, lead magnet and welcome sequence

when one of your posts performs, Claude Code turns it into a page that sells one thing to one kind of buyer, a lead magnet that matches the post, and the welcome emails behind it

it writes the page from the positioning note in the vault, and i rewrite the headline myself before it goes live

after someone signs up, the welcome email goes out right away and the follow-ups take over, and you approve the sequence once

conversion over traffic, always... attention that lands on a page that doesn't sell is wasted

1. the SEO loop

the first job is finding one page where better rankings turn straight into more money, because a sitewide audit hands you a pile of small problems and no idea which one pays

it pulls impressions, clicks and position per page from Search Console, then lines them up next to conversions per page from PostHog

what you want is a page that already converts and already shows up in search, but sits just low enough that searchers never see it

a page with tons of impressions and zero conversions is a trap, and it flags that page as one

then DataForSEO pulls the top 10 pages for the main query, Firecrawl scrapes each one in full, and Claude Code reads them side by side with yours

reading the full pages is the point, because an agent guessing at what a competitor wrote will invent things

you get back what the winners cover that you don't, with a link behind every claim, and when data is missing it says so instead of guessing

1. signal outbound

you write to a company right after something changed: they raised money, posted a job for the role you replace, or hired a new head of marketing

the list comes from Apollo filtered to your buyer, and every first line is about them, never about you

every draft waits for you to read it and send it, and each morning it checks Google Postmaster Tools, so when your emails start landing in spam it lines up fewer the next day

1. competitor placements

pick a keyword you want to own, and it finds the roundups, resource pages and directories that link to several of your competitors, because a page that lists them will list you too if you ask

you get one row per page with a drafted ask, and you send every ask yourself, because a maintainer answers a person and deletes a script

1. ads from the Meta Ad Library

it researches which hooks the best ads in your niche use this month, writes down the structure of each one and leaves the words behind

you copy the skeleton, never the script

every campaign gets created paused, it points out the losers daily, and the budget stays with you

Claude Code writes and lines everything up, and nothing that sends or spends moves without your yes

DeepSeek in pi.dev builds things

every workflow above needs something built: the scrapers, the pages, the forms, the dashboards, and the money loop that catches a failed payment and drafts the follow-up

that's DeepSeek's job, and it runs in pi.dev

pi.dev is a minimal harness, meaning the app you type your agent instructions into, and it's built for you to make your own

it ships with good defaults and skips the extras like sub-agents and plan mode, then you shape it to your workflows with extensions, skills and prompt templates, or you just ask Pi to build what you're missing

the part i like most is the model switch

point it at one OpenRouter API key and you can switch to whichever open-source model is the most efficient that week, even in the middle of a conversation (Pi works with more than fifteen model providers)

a build request can stay this simple:

build a small dashboard that reads our failed payments from Stripe every morning, lists each customer with the amount and the date it failed, and drafts a follow-up email for each one... drafts only, nothing sends, push it on its own branch and tell me when it's ready for review

the builder needs two things before it touches the same project as the writer: a brain shared with everyone, and its own desk so nobody overwrites anybody

one shared brain and one shared memory

a team of specialists only works if every member knows the same things about your business

the strongest version is embarrassingly simple: an Obsidian vault, which is just a folder of markdown files, readable by you and by every agent you run

i run it as Karpathy's LLM Wiki, so the agents write and maintain the pages themselves instead of digging through raw files every time you ask something

when a new source lands in the raw folder, the agent reads it, writes a summary, updates every page it touches, links them together, notes any contradiction, and adds a line to the log

you browse the same folder in Obsidian, follow the links, open the graph view and watch the pages change, which Karpathy describes as Obsidian as the IDE, the LLM as the programmer, the wiki as the codebase

so the brain gets more useful every time something goes in

and a regular lint pass looks for stale claims, orphan pages and missing links, though you still read the pages you depend on yourself, because once the wiki gets big, contradictions between pages can slip past it

five notes carry the business:

• the offer: what you sell, pricing, what's in and out

• the buyer: who buys, what a qualified lead looks like

• the voice: how you write, words you never use

• the playbooks: how each job runs, stage by stage

• the rulings: every decision that should never be re-argued

the rulings note is the one nobody builds and everyone needs, and it's the one i hand to Viktor

every time you correct an agent, Viktor turns the correction into one line in that note, and every agent reads it before working... that's how a correction becomes permanent instead of repeated

the vault syncs to every machine through git, so Viktor, Grok Bot's cloud computer, Claude Code on your laptop and DeepSeek in pi.dev all read and write the same files

memory is the second half

the vault holds what's true about your business, and mem0 holds what the agents learned while working

it's one memory for the whole team, so what one agent learns the others know, and a preference you gave Viktor in Slack shows up the next time Claude Code drafts

every agent connects to mem0's hosted MCP server, and each memory gets tagged with who it's about and which agent saved it, so the team shares one layer and you can still tell the agents apart

mem0 won't split a group conversation into separate memories per speaker by itself, so each agent saves under its own name

the prompt for each agent is one line:

connect to mem0's hosted MCP server with my API key, save what you learn under your own agent name, and search it before every new job

keep the always-loaded part small, a few hundred lines at most, and load everything else on demand, because memory that grows without a ceiling crowds out the actual work

the hard half of memory is forgetting, so give entries a review date and sweep what didn't earn its place

that sweep doubles as a cleanup, since two agents saving the same fact at the same moment can leave you with duplicate memories

and if you went the Viktor route, the pinned message at the top of each channel is this vault in miniature, and it deserves the same care

working on the same project at the same time

now you have a writer and a builder who both want the same landing page

if they work in the same folder, one overwrites the other, and you end up untangling the mess by hand

git worktrees fix that, and the idea is dead simple: a worktree is a second desk on the same project

each desk gets its own folder and its own branch, and they all share the same project history, so two agents never write over each other's files

in practice, Claude Code rewrites the landing page copy at one desk while DeepSeek builds the signup form at another, each pushes its own branch, another agent reviews both, and you approve the merge

the rules that keep the desks clean:

• decide which files each agent can touch before anything starts

• one desk per task, each on its own branch

• give each desk its own port so dev servers don't collide

• merge one branch at a time, with tests between merges

• every agent writes what it did in the log

the review step exists for a reason, because two agents can each make a change that looks fine alone and still break together, like one renaming something the other one still uses

separate desks, one merge lane, and you hold the key to it

Viktor becomes your chief of staff

this is where the team starts working without you in the middle

your agents live in different places, Viktor in your Slack, Grok Bot on its cloud computer, Claude Code in a terminal on your Mac, DeepSeek in pi.dev wherever you run it, and none of them can reach the others directly

Tailscale puts every machine on one private network, like plugging them all into the same office

Agent Tincan is a small relay sitting on that network, and i run it myself

every agent dials out to the relay, so nothing needs an open port, and when one agent asks another for something, the relay queues the request, wakes the other agent and carries the reply back

if an agent is asleep, the request waits in the queue, which means the team keeps working while your laptop is off

no API keys get passed between agents either, since Tailscale tells the relay which machine sent each request

setup is per their docs, and the agents mostly set Tincan up themselves

you pick an always-on machine for the relay, paste one message into the agent there, then paste a join message with an invite code into every other agent

the first message looks like this:

Set up Agent Tincan on this machine: run the relay and be my team's admin. Follow https://agenttincan.com/agents.txt, part A.

one front door

once the relay runs, Viktor becomes your chief of staff

he's always on in Slack, so you talk to Viktor in one channel, he hands the work to Grok Bot, Claude Code and DeepSeek over Tincan, and he brings the answers back to you

and because Viktor sits in Slack, your whole team sees every handoff and anyone can step in

when Claude Code finishes a long job, it asks Viktor to tell you, with a one-paragraph summary in Slack instead of a wall of logs

here's one handoff chain, start to finish:

1. Grok Bot's morning research spots a trend in your niche, and Viktor picks it up

2. Viktor asks Claude Code for a post and a landing page

3. Claude Code writes both and asks DeepSeek to build the page

4. DeepSeek builds it at a separate desk, on a fresh branch

5. a reviewer agent checks the work, then you approve the merge

6. Viktor files everything in the vault for the next run

two rules keep a chain like that from turning into noise:

• name ONE owner at each stage so nobody duplicates work

• every agent verifies before reporting back to Viktor

a bot that says done without checking is worse than no bot

and the safety line i never skip: anything that spends money sits behind your approval, and an agent that reads outside content never gets to boss around a teammate that can spend

because once your agents trust each other like teammates, the real risk is an agent reading a poisoned post or page and getting tricked into asking a teammate with access to your money to do something harmful

each agent owns one job, they all read one brain, they talk over one relay, and you stop being the copy-paste layer of your own business

your job shrinks to the part only you should do, saying yes to the merge, the send and the spend

and if you'd rather have someone working every vertical before you build any of this, hire Viktor as your first AI employee at @viktor_com, it's free to start

use code MACHINA100 for $100 in free credits, Full link in my first reply

In partnership with Viktor