Original author: m4lka (@m4lkxx)
Original article: Grok Bot: 6 Bots, 200+ Agents, a Smaller Bill (Full Setup)
This article is a Chinese-language overview and extended analysis of the original, not a full reprint or paragraph-by-paragraph translation. For the original's complete role prompts, screenshots, and product operating steps, please read them via the link above.
Once you connect a Bot to email, code repositories, calendars, and a knowledge base, it's easy to keep handing it every task. As tasks pile up, so do the problems: rules from different domains get mixed into the same conversation, whether work is done depends on human judgment, and background jobs keep running without a clear account of what those runs produced.
m4lka's article is about how to organize these scattered capabilities into a manageable collaboration system. Drawing on experience with Grok Bot, it discusses role division, task handoffs, acceptance, automation, memory, and cost. Below, I'll first summarize the original's approach, then give a practical example aimed at a personal project.
1. First, Clarify the Six Roles' Responsibilities
The reference team in the original has six roles, including two domain specialists. They carry different responsibilities:
| Role | Main responsibilities | Handoff to the next stage |
|---|---|---|
| CHIEF: single entry point | Understands requests, assigns owners, coordinates cross-domain tasks, summarizes results | Clear goals, division of labor, and current status |
| OPS: operations management | Maintains the task board, checks for blockers, runs regular retrospectives, organizes working rules | Open issues, owners, and improvement items |
| CHECKER: independent acceptance | Judges whether results meet the original goal against evidence | Acceptance verdict plus specific unmet conditions |
| SPECIALIST: domain expert one | Handles work within one stable domain | Deliverables and verification materials for that domain |
| SPECIALIST: domain expert two | Handles another domain that needs its own context | Deliverables and verification materials for that domain |
| MISC: miscellaneous entry point | Takes one-off requests that don't yet have a fixed home | Results for small tasks, or needs worth turning into a reusable skill |
The value of this split is reduced overlap in responsibilities. The entry point knows who to ask, the manager knows where things are stuck, the checker knows what standard to use for acceptance, and executors can keep their own specialist context.
Six roles are one reference org design; the actual setup can be smaller. To decide whether you need a new agent, first ask whether it will handle an independent domain over the long term and whether it needs its own context, permissions, or run schedule. If you're only adding one reusable operation within the same domain, a skill or script is often enough.
2. Tasks Need to Leave Behind State and Evidence
Once the roles are in place, you also need a place to store work state. The original emphasizes using a task board to carry progress so decisions and handoff information don't disappear as chat scrolls.
A task card should answer at least four questions: what is to be delivered, who owns it, what stage it is in, and what conditions must be met for it to close. Statuses can cover pending, in progress, blocked, awaiting acceptance, and done, but what actually makes them work is the rules behind status changes.
For example, moving to “awaiting acceptance” should include the deliverable and evidence; moving to “blocked” should spell out the missing input, permission, or decision; moving to “done” means the agreed acceptance criteria have been met. That way, whoever sees the task card can pick up the work without rereading the whole discussion.
Handoffs should also be as lean as possible. The next executor usually needs the goal, where the deliverable lives, decisions already made, unresolved questions, and what they are allowed to do next. A short brief is easier to check than forwarding a pile of chat and reduces the chance of rereading irrelevant material.
3. Acceptance Criteria Must Come Before a “Done” Verdict
The original gives the independent checker an important role: executors tend to interpret results through their own assumptions, while the checker should go back to the user's original goal.
Coding tasks can provide test output, build results, a running page, or before-and-after comparisons; writing tasks can check sources, attribution of facts, links, and structure. When a check fails, it should state clearly which condition was not met, what problem was seen, and what material needs to be supplied. “Just optimize it a bit more” rarely produces a useful next step.
There are also two kinds of results to distinguish here:
- The deliverable is ready: the code, article, or reply exists and can be reviewed.
- The external action has been completed: content has been published, a message has been sent, or a production system has changed.
The two can have different permission boundaries. Research, organization, and preparing deliverables can usually proceed to a reviewable result; actions involving external sending, money, permissions, or important data should be handled with explicit authorization and attention to real-world impact.
My reading is that independent acceptance mainly changes “who judges completion”; it still needs real evidence. Adding a checker cannot make up for missing sources, the wrong test environment, or an acceptance goal that is itself vague.
4. Memory Should Hold Stable Rules; Business State Must Be Re-Queried
The original separates several kinds of information that are easy to mix together: role descriptions, reusable skills, long-term memory, real-time business sources, and current task state.
Think of them as different storage locations:
| Information | Better place to store it |
|---|---|
| Scope of responsibility, hard constraints, acceptance requirements | Role descriptions and explicit rules |
| Repeated workflows that have already proven out | Skills, scripts, or runbooks |
| Stable preferences, terminology, and long-term decisions | Long-term memory with sources |
| Current prices, permissions, owners, and task status | Real-time sources queried before execution |
| How far this round got and what comes next | Task board and handoff records |
This distinction reduces a common mistake: treating facts that change as long-term knowledge. For example, permissions an account had last week don't prove it still has them today; the owner of a task yesterday may have changed.
When the same error keeps recurring, the original suggests first checking whether there is a fundamental problem with the tool, permissions, or process, and only then considering more checks or turning skills and rules into fixed assets. A rule worth keeping should work across situations, not just record a one-off incident from a particular day.
Also, if multiple roles share the same runtime environment and the same login state, role names alone do not create reliable security isolation. That has to be handled at the level of actual credentials, permissions, and runtime environments.
5. Start Cost Investigation with Triggers and Context
The original lists several kinds of usage waste. They can be grouped into the following four areas to check.
1. Unnecessary Starts
A scheduled job may consume a full run even when it finds no changes. First check whether it really needs to run at high frequency, whether a clearer event can trigger it, or whether you can compare a lightweight signal before deciding to open up the full task.
For example, look first at the last-updated time, a commit identifier, or the number of open items; only when the signal changes should you read larger content and call downstream tools. “Check whether anything changed” should have clear stopping conditions so the check doesn't wander into more pages along the way.
2. Unnecessary History
Putting long day-to-day chats together with recurring tasks makes background work carry more and more irrelevant context. The original therefore suggests paying attention to long sessions, the runtime context of recurring tasks, and whether you can save the necessary state first, then start a more focused run.
What needs preserving here is decisions, deliverables, and next steps, not a mechanical copy of all history. How a specific platform copies sessions, compresses context, or uses caching should be based on what that platform currently supports.
3. Unnecessary Communication and Search
In a group chat, every agent responding to every message, or different agents handing work back and forth without new progress, can expand the workload. A single entry point, clear ownership, and short handoffs can limit that spread.
Requests themselves should include precise enough locating information. If you already know the ticket number or article link, use it directly; monitoring rules should also be limited to genuinely relevant events. An API or connector that can be called precisely is usually easier to scope than repeated browsing and searching.
4. Unnecessary Model Involvement
For deterministic steps such as format conversion, fixed conditional checks, counting, deduplication, and batch filtering, consider scripts first. The model can still handle the parts that require understanding, judgment, and expression, but it doesn't need to reason through every mechanical operation one by one.
Likewise, adding a new feature doesn't necessarily mean adding a long-running Bot. Also check whether archived roles leave behind scheduled jobs, and whether test runs, manual triggers, and background runs are duplicating the same work.
6. How to Read the Savings Numbers in the Original
The original cites usage ratios, task counts, and cost estimates shared by the author and other users. These cases can point to directions worth checking, but this article has not independently verified them, and they should not be used to promise that a given project will save the same percentage.
In particular, keep clear distinctions between token counts, cache reads, call counts, plan quotas, and actual costs—they may be different metrics. A type of input making up a high share does not mean it accounts for the same share of the bill; estimates based on API unit prices also cannot be treated directly as the actual cost of a subscription product.
A safer way to validate is to save your own baseline first, then change one factor at a time. Along with usage and cost, also watch delivery volume, acceptance pass rate, and the number of human interventions. An improvement only counts if tasks are still completed on time and correctly after wasteful runs are reduced.
7. Extended Analysis: Applying It to a Personal Knowledge Blog
The example below is this article's implementation design, meant to show how to turn the above approach into a checkable workflow. It is not a complete configuration provided by the original.
Suppose the input is an external technical article and the goal is to produce a sourced Chinese-language reading note:
- The single entry point confirms the scope, content format, and publishing purpose, and first checks whether a duplicate article already exists.
- The reading-and-writing role organizes the original's points, clearly marks any analysis added by us, and produces a body with sources.
- The check step verifies the author, original link, attribution of facts, explanation of examples, and front-end formatting.
- The publishing step uses the blog's existing API or admin backend and records the article ID, link, and publishing result.
- Later edits continue updating the same article and preserve versions; if a source won't open or is incomplete, record the reason for the blocker.
A task card could look like this:
When this workflow first starts, one executor plus human checks can handle it. As repetitions increase, turn deduplication, field validation, and post-publish checks into scripts; when different domains need independent long-term context, add specialized roles; only then consider unattended scheduled runs.
The most valuable takeaway from the original is to give every run clear responsibility, recoverable state, and checkable results. That way you can explain why the work got done—and when usage rises, you know where to start investigating.