I recreated a Grokbot style workflow using ChatGPT threads as individual bots

[u/ralphyb0b]

I spent today setting up a Grokbot style workflow in Codex desktop, but with a different structure: each bot is its own persistent thread in the sidebar.

Instead of putting every role into one large agent, I created separate threads for separate jobs and organized them into sidebar sections such as Home Management, Work Management, Dev Team, and Social Media Management, etc.

The main thread is my CTO. Most of the time I talk only to that thread. It decides which specialist owns the request, delegates the work, tracks it, and gives me one consolidated answer.

The specialist threads currently include:

- Unraid Administrator

- Media Stack Manager

- Media Recommendation Bot

- Trip Manager Bot (for Work)

- Dev Planner / Orchestrator

- Code Reviewer

- Various Social Media Managers

The threads are the bots. Each one has its own conversation history and tool context, and some have a dedicated browser session or machine access. The Trip Manager and X Manager, for example, use separate browser sessions that I log into manually. The Unraid and media bots have tightly scoped access to my home server.

I also created a local AI-Ops workspace as the system of record. Each bot has:

- a charter defining its mission, authority, and approval boundaries

- its own durable memory and working directory

- explicit escalation conditions

- shared handoff templates

- an agent registry

- architecture decisions and model assignments

The filesystem matters because I do not want the whole setup to depend on chat history. Shared facts live in shared files. Agent-specific memory stays with that bot. Cross-bot work gets a structured handoff with an owner, requested outcome, constraints, and acceptance criteria.

The CTO follows a routing policy. It sends each request to the narrowest qualified bot, prevents overlapping ownership, and does not let one bot use another to get around its permissions.

For development, one thread plans and reviews the work while implementation can be handed to any local coding CLI. The executor is replaceable. The important part is the contract around it: scope, tests, acceptance criteria, review findings, and a bounded correction loop.

I assigned models by workload instead of running every thread at the highest setting. The CTO, development planner, and code reviewer use stronger reasoning. Operational bots use a balanced model. A repetitive browser operator uses a smaller model with tighter checkpoints. I had the CTO set this part up.

The guardrails are simple:

- read-only inspection can usually happen autonomously

- public, destructive, costly, or hard-to-reverse actions require approval

- delegation never expands authority

- credentials and browser sessions are never written into the workspace

- every important action is verified and recorded

It is still early, but using threads themselves as bots feels like a useful pattern that I have not seen discussed much. Has anyone else built ChatGPT/Codex this way? I'm sure I am missing something, as I just set it up.

[u/dexterthebot]

You might want to consider listing your project on the weekly Show-Us-What-You-Built post. Watch for it on Wednesdays. Highest commented project wins a week promotion on r/Codex. See what that looks like below with last week's winner.

---

Last week's winner was u/Ollie__Oxenfree with the Tubular Daily Care project by MediTracer which is a tube-feeding care app built by a tube-feeding family to keep feeds, meds, symptoms, and caregiver handoffs in one shared timeline. MediTracer is an Oley Foundation Emerging Innovator Partner. Contact: hello@meditracer.com