# Rakazo: a self-hosted Grok Bot alternative with your own model and sandbox

> Rakazo is an open-source TypeScript platform for persistent AI teammates, shipped as a web app, an Electron desktop client and an Expo mobile app. The interesting part is not the chat UI, it is that bots keep conversations, memory and a computer you control.

**elie222/rakazo** — Open-source Grok Bot alternative. Choose your own model and sandbox.

- Repository: https://github.com/elie222/rakazo
- Website: https://rakazo.com
- Stars: 3,152 · Forks: 545
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/elie222-rakazo

## The problem: chat assistants that forget and cannot touch anything

A hosted assistant session usually ends when you close the tab. The conversation is stored for you, but the assistant has no persistent identity, no routine, no file system it can call its own. Rakazo's README describes the target as "persistent AI teammates" with "their own conversations, memory, routines, and history". That is a different product shape from a chat window. It is aimed at engineers and small teams who want an assistant that survives restarts, can be reached from a desktop app or a phone, and runs on infrastructure the operator controls. The README also states the project is in beta, which sets the expectation for the rest of this review.

## How Rakazo works: bots, a supervisor, and a computer per bot

The repository is a pnpm and Turbo monorepo. The root package.json declares a dev script that runs four workspace packages together: @rakazo/api, @rakazo/worker, @rakazo/web and @rakazo/sandbox-supervisor. That split tells you most of the architecture. The Hono and oRPC API handles requests. Graphile Worker runs background jobs, which is where scheduled routines and long-running bot work would live. PostgreSQL with Prisma holds state. The sandbox supervisor is a separate process with its own URL and token, and it is what gives a bot a computer.

Computers come in two flavours in the README: "Shared Team Computers and isolated Private computers". Access is described as browser, terminal, file and graphical desktop, so the sandbox is not just a shell. Provider support is listed as Docker, E2B, Daytona, Box and a trusted local computer. Model credentials are brought by the operator through Pi, and app integrations run through Composio or Pipedream Connect, with user-installed Treg, remote MCP and OpenAPI tool sources available without either managed catalog. Bots can also delegate to peer bots or to short-lived subagents, which the README lists as a feature rather than an implementation detail.

## Installing Rakazo from published images

The fastest path needs Docker Engine, the Compose plugin, curl and OpenSSL. No clone and no Node install. The README gives this sequence, which downloads an installer, creates a .env with random secrets and starts the stack. The installer preserves an existing .env when rerun.

```bash
mkdir -p rakazo && cd rakazo &&
curl -fsSLO https://raw.githubusercontent.com/elie222/rakazo/main/infra/compose/install-images.sh &&
bash install-images.sh
```

After it finishes, open http://127.0.0.1:5173, create an account and connect a model. Local Docker computers are on by default; e2b, daytona or box are optional remote providers that need their matching API key. The default image tag is edge, built from main for linux/amd64 and linux/arm64. On restricted networks the README names three escape hatches: override RAKAZO_DOWNLOAD_BASE, skip existing Compose files with --local or RAKAZO_DOWNLOAD_SKIP_EXISTING, or mirror the bootstrap script URL.

## Running bots on a server instead of your laptop

A bot only stays awake while the backend runs, so the README points at a VPS for anything that should be reachable from the desktop and mobile clients. The same installer is used, first with --prepare-only so you can edit .env, then again to start. The documented edits are SANDBOX_PROVIDER set to box, e2b or daytona with its API key, and RAKAZO_HOST set to your domain.

```bash
bash install-images.sh --prepare-only
# edit .env: SANDBOX_PROVIDER=box (or e2b / daytona) with its API key, RAKAZO_HOST=your.domain
bash install-images.sh
```

HTTPS goes in front of port 5173; docs/self-host.md covers the Caddy setup. In the desktop app you then choose Existing instance and enter the https:// address. The README is explicit that public servers must use HTTPS and that HTTP is accepted only for loopback and private LAN addresses, not link-local. The app checks Rakazo's health endpoint before saving.

## Source checkout, Postgres and the sandbox image

Building from source is where the constraints bite. The README requires Node.js 22.22.2 or newer in the 22.x line, Node.js 24.x, or Node.js 26+, plus pnpm 9 and Docker. Node.js 23.x and 25.x are not supported, which matches the engines field in package.json. You copy .env.example to .env and set POSTGRES_PASSWORD, then mirror it inside DATABASE_URL. BETTER_AUTH_SECRET, ENCRYPTION_KEY and SCREEN_PROXY_SECRET must each be independent random values, and Docker sandboxes additionally need a dedicated SANDBOX_SUPERVISOR_TOKEN, which .env.example warns must be distinct from BETTER_AUTH_SECRET.

```bash
docker compose --env-file .env \
  -f infra/compose/docker-compose.yml \
  -f infra/compose/docker-compose.postgres-host.yml \
  up postgres -d
pnpm install
pnpm db:generate
pnpm db:migrate
pnpm sandbox:build
pnpm dev
```

The postgres-host overlay publishes loopback 127.0.0.1:5433 for host-side pnpm and database tools; without it, Postgres stays network-internal and you reach it through docker compose exec. One warning in the README deserves attention: an existing pgdata volume keeps the user, password and database from first init, so those values must stay in .env or be changed in place with ALTER ROLE. The README also states that docker compose down -v deletes all Postgres state.

## Where Rakazo is the wrong choice

The beta label is not decoration. The most recent release listed is v0.1.6 from 2026-09-08, and v0.1.4 and v0.1.5 landed within about a day of it. That cadence suggests active work, but it also means interfaces are moving. If you need a frozen API for a product you ship, this is the wrong dependency right now.

The operational surface is the second issue. You are running Postgres, the API, the worker, the sandbox supervisor and a sandbox provider, and the README's own troubleshooting notes about pgdata volumes and URI-safe passwords exist because those steps go wrong. A single-user chat assistant does not need any of it. There is also a licensing boundary worth reading rather than skimming: the README states that Treg is usage-metered, that self-hosters supply their own Treg token, and that operators embedding Treg in a hosted product should review Treg's integration terms, which require a written agreement for hosted resale. Rakazo itself is Apache-2.0, but that does not cover the third-party services you connect.

## Alternatives and the actual difference in approach

The obvious comparison is the hosted assistant Rakazo positions itself against. A hosted Grok or ChatGPT client gives you a conversation and a model, with no sandbox you administer, no Postgres, and no upgrade path you own. You trade control for the absence of operations. Rakazo inverts that: you bring the model key through Pi, choose the computer provider, and keep the history in your own database.

The closer comparison is a self-hosted agent framework such as OpenHands, where the unit of work is a task you hand to an agent in a repository, and the agent's session is scoped to that task. Rakazo's unit is a bot with a name, a memory, routines and its own computer, which persists between conversations and can be reached from a phone. If your need is "run this migration and open a PR", a task-scoped agent is a better fit. If your need is "a teammate that remembers last week and can use a browser", Rakazo's model matches the problem more directly. The README does not publish a benchmark comparing the two, so decide on the shape of the workflow, not on speed claims.

## Conclusion

Adopt Rakazo only if you want a bot that keeps state and a machine you own, and you are willing to run Postgres plus a sandbox provider yourself. Skip it if you want a single hosted chat window, or if you need a stable API: the README calls the project beta and the release history is days old. Verify first that your chosen model provider works through Pi, that SANDBOX_SUPERVISOR_TOKEN and ENCRYPTION_KEY are set to independent random values, and that the pgdata volume is backed up before any upgrade, because the README states the volume keeps the database credentials from first init.

## FAQ

### Is the Grok Bot open source?

Rakazo is open source under Apache-2.0 and the README describes it as an open-source platform for running persistent AI teammates, positioned as a Grok Bot alternative where you choose your own model and sandbox. The model credentials are yours, supplied through Pi.

### Who is Rakazone Gaming?

That is a different subject. This project is elie222/rakazo, a TypeScript platform for persistent AI teammates, and the README does not mention any streamer or gaming persona.

### What do I need installed before running the Rakazo installer?

The README lists Docker Engine, the Compose plugin, curl and OpenSSL for the published-images path, with no clone and no Node install. Building from source additionally needs Node.js 22.22.2 or newer in the 22.x line, 24.x, or 26+, plus pnpm 9 and Docker.

### Can Rakazo bots keep running after I close the desktop app?

The README states the stack keeps running after the app quits, and that Stop Local Stack in the application menu stops it. For bots that should stay on independently, the README recommends running the backend on a server and connecting from the desktop app, mobile app or a browser.

### Which sandbox providers does Rakazo support?

The README lists Docker, E2B, Daytona, Box and trusted local-computer support. Local Docker computers are on by default after install; the remote options need the matching API key and a SANDBOX_PROVIDER value.

## Sources

- [elie222/rakazo on GitHub](https://github.com/elie222/rakazo)
- [License: Apache-2.0](https://github.com/elie222/rakazo/blob/main/LICENSE)
- [Project website](https://rakazo.com)
- [README](https://github.com/elie222/rakazo/blob/main/README.md)
- [Releases](https://github.com/elie222/rakazo/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/elie222-rakazo