David Ondrej sets himself a specific challenge: build a self-hosted alternative to Grok Bot in public, using coding agents to do much of the implementation. The result is Superbot, an MIT-licensed Rust project with a browser chat interface, multiple named bots and a server that launches existing agent CLIs. It is a real repository, but it is also an early project. The useful story is not that one prompt copied a commercial product. It is how David turned observed workflows into a new application, then exposed the operational work that a polished demo can hide.
Superbot currently documents chat with Claude Code, Codex and Pi, file-based memory, scheduled routines and bot-to-bot messaging. It does not contain Grok Bot's proprietary source code. Approvals and per-bot resource limits are not built, and the repository's own status notes still call the project early. Treat it as a hands-on self-hosting experiment, not a drop-in, audited replacement for a production agent service.
Watch David Build It
The video promotes David's Cloudroom product and a VPS hosting offer. Those are part of the creator's build and promotion, not independent evidence that either service is necessary or the cheapest way to run Superbot.
What “Reverse Engineering” Means Here
David observes how Grok Bot looks and behaves, captures interface screenshots, and asks a bot about its own environment. From there he instructs his agents to implement a similar workflow: persistent bots, conversations, a shared computer, memory and scheduled jobs. This is behavioral reimplementation. The bot's answers about its VM are not a reliable inspection of xAI infrastructure; Superbot's README explicitly calls the underlying architecture a rough guess, not official. The project also states it is not affiliated with xAI or X.
| Evidence | What it supports | What it does not establish |
|---|---|---|
| Public UI and David's demo | A feature brief and visual reference for a new app. | Access to Grok Bot's source, data model or private services. |
| A bot describing its computer | A hypothesis worth testing in a replacement architecture. | Verified VM specifications or a faithful copy of xAI's deployment. |
| The published Superbot repository | Inspectible implementation and documented current behavior. | Feature parity, security certification or production reliability. |
How the Build Unfolds
- Define the target. In the planning segment, David asks agents to map the UI and bot behavior, write a concise project
AGENTS.md, and divide research, frontend and backend work. - Build the shell. A frontend agent turns screenshots into a chat interface. At this point the page is largely visual; a convincing interface is not proof of a functioning agent backend.
- Connect a real harness. The backend work produces the Rust server and a Claude Code CLI integration. David asks for Rust wherever practical, with web code where the browser needs it.
- Deploy and iterate. He provisions a VPS, grants agent-assisted SSH access, gets the app online, then works through login, model choice and custom branding. The demo briefly shows an HTTP deployment and discusses leaving the interface public before adding a password. That sequence is a warning to finish access controls before public exposure, not a setup pattern to copy.
- Maintain the result. David sets up recurring Cloudroom agent loops to review and fix the repository. That maintenance loop is a development workflow around Superbot, not proof that Superbot's own routines can safely auto-deploy code.
What Superbot Actually Runs
The backend guide describes one Rust binary, botd, serving the web app and storing bots, chats and queues in SQLite. A message starts or resumes the selected agent CLI. The server streams text and tool events back to the browser. Bot-specific MEMORY.md files and a shared USER.md carry instructions and preferences into later runs. A second CLI, botctl, handles routines and bot-to-bot requests.
| Layer | Role |
|---|---|
| Browser app | Chat, bot selection, activity updates and model/effort picker. |
| Rust server + SQLite | Queue tasks, preserve sessions, store messages, memory and schedules. |
| Harness adapter | Translate a bot run to Claude Code, Codex or Pi CLI events. |
| Shared VPS workspace | Persistent files and agent tools on one Linux host; not per-bot isolation. |
One bot processes its own queued work in order; different bots can run concurrently. The published design deliberately reuses the coding agents' own loops instead of writing a new general agent engine. That makes adapters small, but it also means behavior and permissions depend on the chosen CLI.
Working Now, Documented Differently, and Still Planned
| Capability | Evidence-based status |
|---|---|
| Chat, memory, routines, bot-to-bot | The current README and backend docs describe them as working in this early release. |
| Claude Code, Codex and Pi | CLI adapters are documented. Grok Build and Hermes are listed as future adapters. |
| Computer and browser control | The computer guide describes a screen, browser profile and live view, but the README still lists computer use as planned. Read this as an evolving, environment-dependent feature, not a proven default install. |
| Action approvals and per-bot limits | The backend guide explicitly says these are not built. Slack and a secret vault are also unfinished. |
A Careful First Run, Following the Repository
- Read the source and requirements. Start with the README, backend guide and configuration template. Review the current commit and open issues before installation.
- Try an isolated, non-sensitive environment first. The official quick start builds with
cargo build --release, copies.env.exampleto.env, fills settings, loads them into the shell and launchesbotd. Keep the default loopback host while validating the app locally. - Install only the agent CLI you intend to use. Sign it in as the same unprivileged Linux user that runs
botd, or configure its provider key. Confirm that its own billing and usage terms cover your intended workload. - Prepare a VPS before opening it to the internet. The project docs call for a normal user,
systemd, HTTPS in front of the server, an authentication password and backups ofDATA_DIR. Keep secrets out of Git and restrict SSH and firewall exposure. - Test one bot with harmless data. Check a chat response, restart behavior, memory changes and scheduled tasks. Review exactly what the CLI can execute before adding real accounts, browser sessions or business data.
This is a guide to the published project, not a report that we installed or security-audited it. For browser/desktop control, read the separate computer guide and confirm its dependencies and current status on the commit you use.
The Trade-Off: Your Computer, Your Responsibility
Self-hosting gives you control over the VPS and files, but it does not automatically make the agents private or safe. The backend docs state that the three supported harnesses run with permission prompts disabled, while action approvals are not yet implemented. They also say all bots share a Linux workspace. The computer guide is explicit that separate screens are not security boundaries: bots run as the same user. A bot that can run commands can potentially read files and credentials available to that user.
For a first deployment, use a dedicated low-privilege account and test data, put HTTPS and authentication in place before enabling remote access, avoid storing broad service credentials in the shared workspace, back up the data directory and review updates before any automatic deployment. Do not mistake a password prompt for per-bot permissions or approval gates. David's later maintenance agents can push fixes quickly; that increases the need for review, rollback and an owner who can shut the service down.
Open Source Is Not Zero-Cost Operation
The Superbot license is MIT. Running it still requires a host, storage and an authenticated agent CLI with its own subscription or API costs. A domain, backups and monitoring add operational cost. The computer-use guide estimates substantial RAM for browser screens, so a tiny VPS may be enough for chat but not for several live desktops. The video advertises a hosting deal and Cloudroom; compare current provider terms rather than treating an affiliate promotion as a lasting price.
Video Chapters
| Time | Topic |
|---|---|
| 00:00 | Project initiation and the open-source goal |
| 01:22 | Architecture research and planning |
| 05:14 | Frontend from screenshots |
| 08:22 | Rust backend architecture |
| 14:23 | VPS deployment begins |
| 18:38 | SSH access and server security |
| 22:06 | First deployment and missing HTTPS |
| 24:37 | Agent harness and model setup |
| 29:03 | Choosing the Superbot name |
| 36:07 | Computer-use integration work |
| 39:14 | Scaling with agent loops |
| 44:26 | Final UI and avatar updates |
| 47:22 | Maintenance and reliability |
| 54:36 | Final delivery and conclusion |
Sources and Limits
The video and supplied transcript establish David's build sequence and statements. Current project status, license and architecture come from the Superbot README, backend guide and computer notes. These documents may evolve, and the README and computer guide currently differ in how they describe computer-use readiness. We did not deploy Superbot, inspect David's private VPS or independently benchmark Grok Bot. Evidence cutoff: 16 November 2026.