When you want a personal AI assistant that does more than chat in a browser tab—something that triages email, runs scheduled scripts, and watches projects in the background—you hit a fork in the road almost immediately. On the left sits xAI's cloud-hosted Grok Bot: it works out of the box and restarts crashed processes on its own, but it locks you into a closed subscription, bars you from swapping models, and stores your history on someone else's servers. On the right sit DIY script chains: total freedom over models, yet the first time a process crashes, your whole automation silently dies until you manually restart the terminal.
I'd been wondering for a while whether you could take the resilient cloud mechanics of xAI's assistant, strip away the proprietary ecosystem, and run it on your own server. Developer David Ondrej actually pulled it off. In his detailed walkthrough, he reverse-engineered Grok Bot's internal architecture and built an open-source MIT-licensed replica called SuperBot in Rust. Let's look under the hood at how it works and how to spin up a team of autonomous bots with any models on your own VPS.
Anatomy of Grok Bot: Inside the VM and Where the Closed Subscription Pinches
To map out xAI's internals without guessing, Ondrej spun up an engineer bot (technical explainer) inside Grok Bot itself and simply asked it in plain English to inspect its own environment. Since the assistant has direct shell access inside its virtual machine, the bot scanned the system and printed the full spec.
One number caught my eye the moment I read that report. Every user's bots live inside a single Debian 13 Linux container on kernel 6.12, backed by 8 Intel Xeon cores and a 128 GB disk with no GPU (no GPU). Out of 15 GB of total RAM, 13 GB are eaten up by system overhead—leaving user scripts with just 2 GB of breathing room.
The platform's appeal (we covered its use cases in our breakdown of Grok Bot's autonomous environment and Superbots swarms) rests on five core springs:
- Process Supervisor: launches bots, collects logs, and instantly revives crashed scripts.
- Scheduler & Routines: wakes agents up on a cron-like schedule.
- Message Bus: passes tasks and files between bots.
- Memory Separation (
statevs.scratch): keeps long-term settings apart from temporary sandbox files. - Guardrails & Observability: caps resource usage and shows active tasks.
The catch is that in the original product, all of this engineering is chained to a single model—Grok 4.7. For everyday chores like sorting resumes, it's less stiff than the heavily guarded Fable 5.2, yet on software architecture it trails flagship Opus 5.5. Inside the closed interface, you can't swap the model per task, tune reasoning depth, or keep your working files on your own server.
The SuperBot Rust Core: Subagent Isolation and Plain-File Markdown Memory
Rebuilding the platform in the SuperBot repository, Ondrej ditched heavy scripting languages and wrote the core in Rust (67% of the codebase). Put into everyday terms, it's the difference between a lumbering RV and a featherweight titanium bike. Servers built on Python or Node.js keep an interpreter and a garbage collector running in memory at all times—an automatic janitor that reserves hundreds of megabytes as a buffer and periodically pauses work to sweep up old variables.
The Rust compiler (Cargo) verifies memory safety at build time and packs the server into a single compact static binary with zero runtime overhead. At idle, the SuperBot daemon uses under 50 MB of RAM, doesn't leak memory over days of uptime, and responds instantly in the browser.
Inside the daemon, labor is cleanly divided. The root agents.md file tells models to keep answers crisp and splits roles between the main coordinator and specialized subagents:
- Coordinator (
SuperBot): takes your request in chat, breaks it into steps, and dispatches tasks over the message bus. - Inbox Subagent (
Inbox): hooks into email CLI tools and processes incoming notifications. - Research Subagent (
Researcher): searches the web and documents, cross-checks figures, and drafts summaries. - Developer Subagent (
Developer): writes and tests code in an isolated directory.
What I liked most is how pragmatic the long-term memory (plain-file memories) is. Instead of heavy vector databases, SuperBot stores a clean hierarchy of ordinary Markdown files right on disk—holding your preferences, task history, and project context. You can open any memory file in a text editor and tweak it by hand.
Deploying on Your Own VPS: From Compiling the Binary to Parsing Email
Because the Rust daemon needs less than 50 MB of RAM, a basic Linux VPS for $4–5 a month is plenty for the whole station. Let's trace an end-to-end example: spinning up SuperBot on an Ubuntu 24.04 server in Warsaw and having it compile an invoice report from your inbox.
First, lock down the server: disable password logins in favor of SSH keys, turn on the UFW firewall, and export your ANTHROPIC_API_KEY and OPENAI_API_KEY. Then clone the repo, build the release binary, and start the server on port 8080 with claude-3-5-sonnet:
# Clone and build
git clone https://github.com/davidondrej/superbot.git
cd superbot
cargo build --release
# Start the daemon with a chosen provider
./target/release/superbot --host 0.0.0.0 --port 8080 --model anthropic:claude-3-5-sonnet
Here's what happens at runtime. The --release flag tells cargo build to strip debug symbols and turn on speed optimizations, producing the ./target/release/superbot executable. Passing --host 0.0.0.0 --port 8080 spins up the web UI and process supervisor, while --model anthropic:claude-3-5-sonnet wires up the provider adapter (on a real VPS, you'd wrap this in a systemd service for auto-restart and protect the dashboard with a password or SSH tunnel).
Open the web panel with its custom SVG robot icons and send a task: "Analyze my inbox, find last month's invoices, and put together a Markdown summary report." The SuperBot coordinator delegates email fetching to the Inbox subagent, which pulls the invoices via a CLI tool and hands them to Researcher. A minute later, a finished Markdown table lands in file memory—no manual copy-pasting required.
Swapping External Models and Harnesses: Token Economics and Limits
Above the input box in SuperBot sits a selector for the model and reasoning depth (medium, high, extra high). Underneath, it relies on an agent harness (Claude Code CLI, Codex CLI, or Pi) that gives the model access to files and a terminal. By plugging in the official Claude Code CLI, you stay within Anthropic's terms and use your own subscription directly.
Ondrej burned through 100% of his heavy Fable 5.2 quota, whereas a 90-minute build of SuperBot inside Cloudroom using fast Opus 5.5 with five cloud agents ate less than 1% of his monthly allowance. The adapter layer lets you mix and match providers strategically:
- Daily tasks and background loops (
Claude Code CLIonOpus 5.5orSonnet): saves tokens on recurring checks (agent loops)—like a bot scanning your repo three times a day or runningCyber Defendersecurity audits (we covered how triggers cut quota burn by up to 82% in our Grok Bot optimization guide). - Independent code review (
Codex CLIandOpenAI API): cross-model verification (GPT review) before merging changes intomain. - Local models (
vLLMandOllama): processing sensitive company documents entirely inside your perimeter.
- Manual ops: SSH keys,
UFWrules, backups of your Markdown memory, and Ubuntu updates are all on you. - Background API burn: frequent checks set to maximum reasoning depth will chew through your token balance fast.
- Hardware ceiling: a $4–5/month VPS has no GPU and won't run 70B+ local weights—for those, you need external APIs or a GPU instance.
So getting Grok Bot's capabilities without a walled garden or rigid limits is completely doable: spin up SuperBot on a cheap Linux VPS and plug in your own keys. Building a station like this in an hour and a half shows where the industry is headed by 2027. We're moving past manual back-and-forth with chatbots toward autonomous agent loops on inexpensive personal servers—where you're no longer the bottleneck for routine work and only step in for the decisions that actually matter.

