Grok Bot teams directory

Six Bots run the company week. Product holds the list. Coding ships. Findability is SEO, AEO, and GEO. Marketing drafts. Trust reads security and legal. Money reads Stripe.

Treats generative answers as a citation problem, not a keyword list, and drafts the pages that earn those citations.

Reads Search Console and DataForSEO once a week, names what moved, and writes the next fix instead of another dashboard.

Watches competitor sites, ads, and prices as they change, and writes a brief that separates shipped from announced.

Watches conversion and intent, drafts the next reply or experiment, and leaves affiliate-grade stacks alone.

Reads live spend and creative, recommends the next reallocation and the next test, then waits.

Turns one ship into a short-form queue for YouTube, TikTok, Instagram, and Threads, then parks it for a human to post.

Drafts X posts, reads replies and quotes, and proposes tests a human tweets.

Picks audience tests across YouTube, Instagram, TikTok, and Threads, then reports what moved followers and what to stop.

Gets a shipped indie product in front of people with changelog notes, X and HN drafts, and directory listing notes a human posts.

Answers whether the studio can take the next project, using booked time rather than an optimistic guess.

Closes finished projects properly: final assets filed, client access reviewed, last invoice checked, and a retro written while people still remember.

Runs the pitch pipeline from first inbound enquiry to sent proposal, so nothing sits unanswered while a prospect waits.

Tracks every retainer against the hours actually delivered, and names the accounts quietly running over before the invoice does.

Watches what the company owes: bills in, duplicates caught, and nothing paid twice or paid late by accident.

Chases what the company is owed: who is late, by how long, and what the follow-up should say, ready for a human to send.

Walks the monthly payroll: headcount changes checked, hours confirmed, and every variance explained before anyone approves a payment.

Keeps filing deadlines and the numbers behind them in one place, so a return is never assembled the night before it is due.

Finds the people already helping in public, keeps track of what they did, and makes sure they get thanked by a human.

Keeps a busy Discord answerable: unanswered questions surfaced, repeat questions turned into docs, and moderation load made visible.

Sorts a public forum so questions reach the right people and answered threads become documentation instead of disappearing.

Runs a launch inside the community: the announcement drafted, questions anticipated, and the first day's reaction reported honestly.

Reads drafts before a human editor does, catching claims without sources, house-style breaks, and the things that get fixed at the last minute.

Keeps a newsletter shipping on schedule: the issue assembled, links checked, and the retro written against what people actually opened.

Turns one long piece into the shorter pieces it should have become, in the register each channel actually uses.

Watches which pages actually earn traffic, finds the ones decaying quietly, and drafts the update rather than another new post.

Reads what the audience actually says across platforms and turns it into the next thing worth making.

Runs a creator product launch: the sequence drafted, the page checked, and the first week reported without flattery.

Runs the short-form pipeline: which long videos have a clip worth cutting, and what each cut needs to work on its own.

Handles brand deals end to end: inbound qualified, fit judged against the audience, deliverables tracked, and nothing over-promised.

Keeps experiments honest: what was predicted, when to stop looking, and whether the result actually says what people claim.

Keeps one definition per metric, so two teams stop quoting different numbers for the same word.

Checks the numbers before anyone quotes them: freshness, row counts, and the joins that silently drop records.

Runs the ad-hoc data request queue so questions get answered once and the answer is findable next time.

Keeps public surfaces on-brand without a human having to check every page by hand.

Makes sure what engineering receives is buildable: states covered, edge cases named, and copy that actually exists.

Turns scattered user sessions into findings people can act on, with the evidence attached.

Keeps the component library and the product from drifting apart, and names the drift when it starts.

Keeps a debt list ranked by how often it actually hurts, rather than by who complained most recently.

Makes the shift handover a written record instead of a conversation someone half remembers.

Answers what actually shipped, what it changed, and whether anything got worse afterwards.

Stops pull requests going stale by making the wait visible, without nagging anyone directly.

Handles a conference presence: sessions tracked, meetings booked, and every conversation written down before it is forgotten.

Runs small in-person events where the budget and the guest list are the two things that quietly go wrong.

Tracks what was bought at an event and whether any of it was delivered.

Runs a webinar end to end: registrations watched, reminders drafted, and the follow-up ready before the call ends.

Prepares board meetings from the real numbers, and tracks what was decided afterwards.

Runs a raise like a pipeline: who was met, what they asked, what was promised, and what is outstanding.

Handles hiring while it is still the founder's job, without letting candidates sit unanswered.

Keeps one honest answer to how long the money lasts, updated from what actually happened.

Makes sure hard tickets reach the right person quickly, with the context already assembled.

Keeps canned replies accurate, because a wrong saved reply is worse than no saved reply.

Watches promised response times and warns before one is missed, not after.

Keeps support replies consistent and human, and catches the ones that read like a form letter.

Handles the offer stage where speed matters most, and keeps the terms consistent with what was discussed.

Keeps candidates moving and makes silence visible, because slow rejection costs more than fast rejection.

Keeps referrals from disappearing, since they convert best and get chased least.

Keeps hiring decisions evidence-based by chasing the scorecard while the interview is still fresh.

Checks that backups exist and could actually be restored, which is not the same question.

Answers whether the system survives the next spike, before the spike rather than during it.

Turns a cloud bill into named decisions, so spend growth has an owner rather than a shrug.

Watches the boring security surface that gets ignored until it does not: keys, permissions, and exposed endpoints.

Turns vague investor offers of help into specific requests, and tracks whether anything came of them.

Keeps the data room current between raises, so diligence does not become a fire drill.

Drafts the monthly letter with the bad news first, and tracks what was promised in the last one.

Assembles the same metrics the same way every month, so the trend means something across a year of updates.

Records what was decided and why, so the same argument is not had twice a year later.

Keeps the documents a new joiner actually reads in their first week correct, because those are the ones that mislead.

Keeps operational runbooks correct, since a wrong runbook is read at the worst possible moment.

Measures whether people can find what exists, and fixes the naming that stops them.

Keeps one list of what the company signed, what it committed to, and when each obligation lands.

Watches the marks and filings that quietly lapse, and the places the brand is used without permission.

Tracks what personal data the company holds, where it goes, and which requests are running out of time.

Reviews what the company is about to sign, and flags the terms that matter before signature rather than after.

Runs the first two weeks of a new employee so nothing depends on one person remembering the checklist.

Runs a large rollout where the buyer and the users are different people with different problems.

Watches where self-serve users drop out before they ever reach value.

Gets a customer's integration actually working, and names where they got stuck rather than assuming they will say.

Runs joint campaigns where both sides have to deliver, and makes the missing half obvious early.

Tracks technical partnerships through the part that actually breaks: the integration staying alive after launch.

Keeps channel partners selling accurately, and makes deal registration something people actually do.

Finds and qualifies potential partners against what the product actually needs, not against logo appeal.

Keeps product decisions attached to evidence, and says plainly when there is none.

Turns scattered feedback into counted, sourced themes rather than whoever shouted most recently.

Coordinates a feature launch so support, docs, and sales are ready before customers arrive, not after.

Keeps the roadmap something people can trust, by making slippage visible the week it happens.

Watches how the process actually feels from outside, and reports the parts nobody would admit to.

Answers what a role actually costs and how long it takes to fill, before the search starts.

Writes outreach that names the person's actual work, and stops the sequence the moment someone replies.

Builds a candidate list from evidence of work rather than from job titles, and keeps outreach from repeating itself.

Tracks what competitors actually shipped and said, separated from what they announced.

Keeps a running picture of what customers say, built from evidence with the quote attached.

Answers sizing and segment questions with the source and the date attached, so numbers can be checked.

Turns finished research into something people can actually use, and says when the answer is not known.

Reads cancellations for the reason rather than the reason box, and separates the preventable from the rest.

Finds accounts that have outgrown their plan, and separates that from accounts simply being squeezed.

Builds a forecast from committed evidence and shows how wrong the last one was.

Watches what customers actually pay against list, and where discounting has quietly become the default.

Prepares demos against the prospect's actual problem, and records what was promised in the room.

Runs outbound where the research is real and the sequence stops the moment someone answers.

Keeps proposals accurate and consistent, and stops silence being mistaken for consideration.

Splits accounts so coverage is even and no account sits unowned for a quarter.

Turns scattered usage and support signals into a plain answer about which accounts are actually in trouble.

Runs the first ninety days of a new account so the handover from sales does not quietly become nobody's job.

Prepares the quarterly business review from real usage and real outcomes, not a slide template.

Tracks every renewal far enough ahead to do something about it, with the case for renewing written from evidence.

Turns the questions support answers repeatedly into documentation that stops them.

Handles the support side of an outage: one accurate message, updated, instead of forty different answers.

Contacts nobody, but finds the customers about to have a problem so a human can reach them first.

Reviews resolved tickets for whether the answer was actually right, not merely fast.

Runs the internal IT queue so requests do not sit unanswered and access is granted deliberately.

Makes the real cost of the calendar visible, and kills the meetings nobody would defend.

Keeps internal policies findable and current, and tracks who has actually read them.

Finds the subscriptions nobody uses and the ones nobody remembers approving.

Runs a data floor: warehouse checks, product analytics read, model failures caught, and a weekly note on which numbers are unsafe to quote.

Runs a design studio: Figma comments chased, assets tracked, specs drafted for engineering, and board hygiene kept after sessions.

Watches issue triage, backlog drift, production errors, and deploy failures, then says what needs a human decision.

Runs a ticket desk across Zendesk and Intercom: triaged by urgency, aging conversations surfaced, and repeat tickets turned into bugs.

Watches metrics, on-call pages, edge errors, and database health, and reports what degraded without touching production.

Runs a knowledge base across four stores: stale pages found, duplicates named, records checked, and gaps in documentation reported.

Runs a revenue floor: stalled deals surfaced, CRM records kept honest, call commitments pulled out, and no-shows followed up.