rakazo

Rakazo is an open-source platform for running persistent AI teammates — bots with their own conversations, memory, routines, and computers that continue to exist and work between sessions rather than resetting with every chat. Positioned as an open alternative to closed, single-vendor bot platforms, it lets teams and individuals bring their own model and infrastructure instead of committing to one hosted provider.

Each bot gets full computer access — browser, terminal, file system, and a graphical desktop — running in Docker, E2B, Daytona, or Box sandboxes, or on a trusted local machine. Shared Team Computers give multiple bots a common file system, installed tools, and browser identity within a trust boundary, while Private Computers keep a bot’s working state isolated. Bots can delegate work to peer bots or spin up short-lived subagents, and connect to external services through Composio, Pipedream Connect, remote MCP servers, or OpenAPI tool sources.

The same backend powers a web app, an Electron desktop client, and an Expo mobile app, plus voice mode (bring your own ElevenLabs, OpenAI, Cartesia, or Fish Audio key) and messaging integrations. Rakazo ships as published Docker images with a one-command installer for self-hosting, or as source for local development against Postgres, Prisma, and Graphile Worker.

What You Get

• Persistent bots with durable conversation, memory, routines, and history that survive restarts
• Full computer access per bot — browser, terminal, files, and a graphical desktop — backed by Docker, E2B, Daytona, or Box sandboxes
• Voice mode with bring-your-own ElevenLabs, OpenAI, Cartesia, or Fish Audio credentials for spoken replies, dictation, and phone-style calls
• Shared Team Computers with a common file system and browser identity, plus isolated Private Computers when work must not be shared
• Bot-to-bot delegation and short-lived subagents for splitting up multi-step work
• App integrations via Composio, Pipedream Connect, user-installed MCP servers, Treg, and OpenAPI tool sources
• One codebase shipped to browser, Electron desktop, and Expo mobile clients

Common Use Cases

• Running a self-hosted AI teammate that keeps context and memory across weeks of ongoing work instead of restarting each session
• Giving a bot its own sandboxed computer to browse, run terminal commands, and edit files on a task without touching the operator’s own machine
• Coordinating a team of bots on a shared Team Computer so they see the same files, tools, and logged-in browser sessions
• Automating routine work — scheduled prompts and message-triggered runs — instead of prompting a chat window by hand each time
• Connecting a bot to existing SaaS tools (via Composio/Pipedream) or internal systems (via MCP/OpenAPI) without hardcoding each integration
• Talking to a bot by voice from the desktop or mobile app instead of typing

Under The Hood

Architecture Rakazo is organized as a pnpm/Turborepo monorepo with clearly separated apps (api, worker, web, desktop, mobile, www) sitting on top of a shared package layer (core, adapters, adapter-kit, auth, contracts, db, memory, logging, chat-ui, ui-web, ui-tokens). The API and worker processes are built almost entirely through dependency injection: the API’s app-composition function and the worker’s entry point each assemble a sandbox provider, agent runtime, messaging surface, realtime fanout, and job publisher from small factory functions before wiring them into a Hono app or a Graphile Worker job host. Cross-cutting concerns — job reconciliation leadership, encrypted secrets, connector registries, messaging inbound/outbound — are themselves injected rather than imported as singletons, so the same executor and job handlers run identically whether the process is the always-on API or the background worker. Swapping the core agent-runtime abstraction (a real model-backed runtime vs. a scripted one used throughout the test suite) or the sandbox provider (Docker/E2B/Daytona/Box) touches only the small factory functions at the composition root, not the executor or router logic that consumes them.

Tech Stack The stack is TypeScript end-to-end: Hono and oRPC on the API, React 19 with Vite and Tailwind CSS for the web client, Electron for desktop, and Expo for mobile, all sharing the same internal packages. Persistence is PostgreSQL through Prisma (with the pg driver via a dedicated Postgres adapter), with Better Auth handling authentication and Graphile Worker driving the background job queue and reconciliation. Sandboxed “computers” are backed by Docker (through a supervisor HTTP API), E2B, Daytona, or Box depending on configuration, and integrations reach outward through Composio, Pipedream Connect, remote MCP servers, and OpenAPI tool sources. Build tooling is Turborepo with Biome for linting and formatting and Vitest/Playwright for testing, with dedicated scripts for integration, e2e, canary, topology, and performance test suites.

Code Quality Test coverage is extensive and colocated: several hundred test files sit directly beside the modules they cover, using Vitest with mocked globals and explicit timeout-based assertions rather than real network calls. Continuous integration runs lint, a full type check, production builds, an Electron end-to-end smoke test, and a dedicated unit-test job, plus separate nightly and topology verification workflows for deeper checks. Error handling favors explicit, narrow catches with comments explaining the exact race condition or shutdown-ordering concern being guarded against, and the linter/formatter enforces consistent style and import order across the whole monorepo. The areas inspected read as thoroughly typed, tested, and linted, with CI enforcement on every change.

What Makes It Unique Rakazo’s distinguishing idea is treating a “computer” as durable, shareable working state rather than a disposable execution sandbox: a Team Computer persists a checkpointed browser identity and installed tools across bots, uses generation fencing so an older desktop can’t overwrite newer shared state, and degrades explicitly rather than silently on providers that can’t support concurrent live desktops. Combined with bot-to-bot delegation, short-lived subagents, and a provider-neutral contract layer for models, memory, sandboxes, and messaging enforced by deterministic offline conformance tests per adapter, this pushes further than typical single-session agent frameworks toward a persistent, multi-surface teammate that keeps working and remembering between sessions. It is a strong synthesis of existing ideas — sandboxed agents, computer use, multi-provider abstraction — rather than a wholly new primitive.

Self-Hosting

Licensing Model Apache License 2.0 — all core features, including the web, desktop, mobile clients, and self-hosting infrastructure, are available under an OSI-approved permissive license with no license key required.

Self-Hosting Restrictions None found. The published Docker images and a full source checkout both run the complete product; no feature observed is gated behind a paid tier.

Enterprise Features No separate enterprise tier exists as of this analysis — the project is in beta with a single open-source edition.

Cloud vs Self-Hosted There is no distinct hosted/cloud product with additional features. Project documentation mentions a possible future managed Rakazo service purely as a convenience option, explicitly stating it should not become a hidden dependency of the self-hosted core.

License Key Required No.