Atlas AI Resources

Article

Only One of My Grok Bots Is Allowed to Publish

By Austin Hoopes · Published November 10, 2026

Several of my Grok Bots write files for this site. Another checks their facts. Exactly one is allowed to put anything live.

The bot that helps me write these articles is one of the six. This piece waited in the same queue as everything else. Here’s how that queue works and why I set it up. About a four-minute read.

Too many hands on one folder

Each bot that writes here has its own corner. One writes the guides. One writes the news. One keeps the prompt library. One runs the tools directory. One owns the SEO plumbing: the sitemap, robots.txt, and the 404 page. One helps me with these articles.

They all live on the same computer, because my bots share one. And the live site is built from one folder on it.

For a while, several of those bots could deploy their own work once it passed its checks. My first fix for the obvious risk was a lock file: before deploying, a bot checks for a short note that says another bot is mid-deploy, and waits if the note is fresh.

The lock answered one question: is anyone deploying right now? It didn’t answer the more useful one: who is responsible for what the whole site looks like after a deploy? With several bots each pushing their own pages, the honest answer was everyone, which is close to nobody.

So in late October I changed it. One bot publishes. Everyone else hands off.

The handoff is a file, not a chat

When a writer finishes a page, it doesn’t ask the publisher to put it live. It writes a ticket: a short text file in a queue folder.

The ticket says which files go where, which live URLs to check afterward, whether the SEO pass is done, and whether the fact check passed. Then the writer sends the publisher one line saying a ticket is ready, and goes back to its own job. It doesn’t wait for an answer.

I like this more than I expected to. A chat message is a request. A ticket is a record. If something goes wrong a week later, I can read exactly what was handed over and what was claimed about it.

Before any ticket gets written, two other bots look at the draft. The SEO bot checks titles, descriptions, links, and image text. The fact-checker checks every claim against its source. They each review the draft, and the writer applies both sets of fixes. The checker being a different bot from the writer is a rule I already trusted. (That story is in What Running Thirty Grok Bots Actually Looks Like.)

What the publisher actually does

The publisher runs in batches, twice a day. If the queue is empty, it says nothing.

When there are tickets, it takes the lock and reads them oldest first. A ticket that doesn’t say the fact check passed gets moved to a held folder, and the writer is told why. So does a ticket that lists one of the private files, like notes, logs, or scripts, that should never be on a public site.

Then it runs a check script. The script confirms every page’s header menu matches the home page’s, every footer carries the shared footer links, and no private files have slipped into the live folder. If the check fails, nothing deploys until it’s fixed.

If it passes, the publisher deploys, loads every URL from the tickets, and confirms each one comes back. Afterward it tells the SEO bot about the new pages so they go in the sitemap, tells the fact-checker so it can recheck the live versions, tells each writer its pages are up, and sends me one short message instead of one per ticket.

If a deploy fails, it doesn’t retry in a loop. It tells me once, with the error, and leaves the tickets where they are.

The boring parts go to a script

One part of this is not a bot’s judgment at all. Whether a header matches, whether a footer link is missing, whether a private file is sitting in the public folder: those are yes-or-no questions. A script answers them the same way every time, and the publisher doesn’t get to talk its way past a failing check.

To be clear about what this is: it’s not a Grok Bot feature. It’s a set of written instructions my bots read, a folder, and one small script. The bots follow the instructions because the instructions are part of their jobs. The script is the only piece that checks the result mechanically.

That split feels right to me. The writing is where a model earns its keep. Whether a footer link exists isn’t. (If you want the longer version of that idea, see Decision models: fast, typed answers for routine agent choices.)

What it cost

Speed, mostly. A finished, checked page can sit in the queue until the next batch. Nobody gets to push something live the minute it’s done.

I’m fine with that. Nothing on this site is so urgent that a few hours matters, and in exchange I know which bot to ask when something on the live site looks wrong. There’s exactly one.

The publisher’s job is narrow, too. It doesn’t rewrite other bots’ pages. The only thing it fixes in someone else’s page is the shared header and footer, and then it tells that writer to fix its template so the problem doesn’t come back. (More on keeping jobs that narrow in What is a one-job Grok Bot?)

If several of your bots write to the same place

For more on how bots hand work to each other on a shared computer, see Small AI fleets: handoffs, group chats, and the shared computer.

Where in your own setup do two bots both think they own the last step?

About the author

Austin Hoopes runs a fleet of Grok Bots that handle his inbox, research, and writing, and writes here about what actually holds up day to day.

← All articles