Why CTOX Docs Connectivity GitHub Install

A Rust daemon that runs your team's apps.

CTOX is an agent runtime and app platform in one self-hosted binary. The daemon keeps durable state in SQLite, executes long-running agent work, and serves the Business OS: web app modules your team uses in the browser, replicated peer-to-peer over WebRTC. Agents build and modify the apps at runtime — every change versioned and reversible.

Install CTOX Open source, AGPL-3.0. Install on one host, or manage local and remote instances with the Desktop Beta.

What CTOX is

App platform and agent runtime in one binary.

An internal tool normally drags a stack behind it: hosted database, auth service, deployment, monitoring — per app. CTOX collapses that into one daemon on a machine you control. Apps are HTML/JS modules served to the browser, data lives in SQLite and replicates to browser IndexedDB over WebRTC, and agents change schema and code at runtime instead of through a redeploy.

One binary A persistent Rust daemon: SQLite state, WebRTC sync, work queues, and an agent harness. No external services required to run it.

Apps as modules Business OS apps are HTML/JS/CSS modules. On start, the runtime hands them data access, commands, permissions, the signed-in user, windows, files, chat, and notifications.

Changes at runtime Agents alter module code and SQLite schema in place through the daemon. No build step, no redeploy.

Versioned and reversible Every module change is SHA-256-hashed, versioned in the daemon's database, and can be rolled back to any previous state.

What actually runs

CTOX turns ongoing technical work into tracked runtime state.

State database

runtime/ctox.sqlite3 stores queues, tickets, governance, channels, schedules, plans, knowledge, continuity, verification, and claims.

Daemon loops

The service starts channel routing, channel syncing, mission watching, CTO operating checks, and the backend supervisor.

Work controls

ctox queue, ticket, plan, schedule, channel, governance, verification, process-mining, and state-invariants inspect and control that state.

Knowledge

Findings, decisions, known issues, and useful context are persisted so the next run starts from recorded state instead of chat memory.

Fluid workspace shell

Desktop app beta

Apps your team uses — and changes — while they run.

The Business OS is the browser shell the daemon serves. Your team signs in and works with modules: records, pipelines, files, tasks. Any module can be changed in place — right-click a grid or a view, describe the change, and an agent patches the module's schema or code.

From right-click to patched module

The animation below is the actual flow: a context-menu request becomes an agent job in the daemon. The agent edits the module's HTML/JS in place, hashes the bundle, stores the new version, and the interface updates live — with rollback one click away:

example-workspace / ctox-pipeline

Live-Modus

Lead-Name

Deal-Wert

Status

Prio

Milton S.

24.500 €

Offen

Medium

Irena M.

12.000 €

Terminiert

Low

Milton P.

68.000 €

Verifiziert

High

Was soll angepasst werden?

Daemon verarbeitet Code-Änderung...

✓

App-Ansicht angepasst Version 12 versiegelt (modver_pipeline_12)

Schema changes at runtime A new field or a scoring column is a schema change in local SQLite. The daemon applies it, populates the records, and the sync engine replicates it to browser IndexedDB.

Code changes at runtime A new button, form, or view is an in-place edit of the module's HTML and JavaScript. The daemon serves the new version immediately — no build, no redeploy.

Peer-to-peer data plane Replication runs over WebRTC between browser IndexedDB and the daemon's SQLite. Signaling carries SDP/ICE only; there is no HTTP data proxy in the path.

Versioned and reversible Each patch is SHA-256-hashed, sealed, and logged in the daemon's database. Any module rolls back to any previous version in one click.

CTOX Business OS competitive analysis dashboard with ranking and portfolio map — **Research workspace** Scoring criteria and watchlists were added at runtime through right-click requests during active work.

CTOX Business OS sales pipeline with candidate automation and research database request — **Pipeline module** Qualification rules and lead status criteria were changed through context-menu requests instead of a redeploy.

CTOX Business OS leads workspace with lead accounts and actions — **Records workspace** Custom contact properties, offers, and task relations were extended into SQLite and IndexedDB at runtime.

CTOX Business OS knowledge store with skillbooks and runbooks — **Knowledge store** Runbooks and skill files are editable data the daemon reads on its next run.

Business OS connectivity

The browser does not need a direct IP route to CTOX.

CTOX can be public, routed through ctox.dev, or private behind NAT. The browser only needs the static Business OS shell and a pairing config. Data moves through CTOX Sync Engine WebRTC replication between browser IndexedDB and the Rust daemon's SQLite store.

Browser ctox-rxdb-js.mjs, CTOX Sync Engine, IndexedDB, module shell.

same room password CTOX Sync Engine WebRTC collections module catalog, runtime state, commands, files, channel data.

CTOX rxdb-rs, RxStorageSqlite, runtime/ctox.sqlite3.

public host

CTOX has its own domain

CTOX serves the shell and injects session plus pairing config. The data plane still stays RxDB/WebRTC.

managed edge

ctox.dev subdomain

ctox.dev routes or serves the shell. Pairing data opens the WebRTC room, not an HTTP data bridge.

private instance

No inbound IP route

The desktop app or ctox.dev can deliver the shell while CTOX connects outbound to signaling.

Core Guarantees

Control and safety, built into the daemon.

Changes without redeploys

Module code and schema changes are daemon operations, not deployment cycles. On request, an agent edits the raw HTML/JS/CSS modules and restructures local SQLite tables in place — and every one of those edits goes through the versioning path below.

The daemon is the authority

The browser is a client, not the source of truth. Every transaction, queue task, and command execution is validated in the Rust daemon against 12 formal transition gates and 5 core state invariants.

Audited mutations

Every database mutation is recorded through SQLite triggers into an audit trail. That trail supports Petri-net and DFG process discovery, deadlock checks, conformance audits, and safety-violation scans.

Rollback built in

Every module patch is versioned, hashed, and sealed inside the daemon. A single click from the App Store drawer rolls a module's files and directory state back to its precise baseline.

Install

Install CTOX on the host that should carry the work.

Use the terminal path when you are already on the target host. Open the TUI to configure runtime, communication, tickets, and remote access. Use the Desktop Beta when you want a guided setup for this machine or remote servers, and when you want to manage more than one CTOX instance from one place.

Terminal install

Use this when you are already on the server or SSH session that should run CTOX.

curl -fsSL https://raw.githubusercontent.com/metric-space-ai/ctox/main/install.sh | bash
ctox
ctox start
ctox status

Run the installer on the host that should own the work.
Open ctox to configure model/runtime, communication, tickets, and remote access.
Start the daemon and check status before handing it real work.

Desktop Beta and instance manager

The CTOX Business-OS Desktop app is currently beta. It can prepare CTOX on this computer or on SSH hosts, connect to remote WebRTC hosts, and keep multiple local or remote instances in one registry, but it should be treated as a test build until the production gates are closed.

Agent skill for Codex, Claude, and MCP clients

Install the CTOX Business OS deploy skill when you want a coding agent to install CTOX, connect Business OS MCP, or interact with a CTOX instance through supported typed tools.

https://github.com/metric-space-ai/ctox-business-os-deploy-skill/tree/main/ctox

Install CTOX on the local machine or an SSH host with the official installer, then verify ctox doctor, ctox status, and Business OS readiness.
Connect local, managed mcp.ctox.dev, or self-hosted Business OS MCP endpoints with the right bearer-token flow.
Use typed MCP tools to inspect modules, records, runs, artifacts, approvals, and to create or modify runtime-installed Business OS apps with validation, smoke, and E2E checks.
Keep Business OS data on RxDB/WebRTC; the skill explicitly avoids raw SQL, browser remote control, and HTTP data proxy fallbacks.

Current release

Checking latest release assets... View releases

Open latest release

CTOX Business-OS Desktop is currently shipped as Beta. Use it to test managed ctox.dev instances, SSH installs, local instances, and manual pairing; do not present it as production-ready.

Optional Business-OS Desktop Beta installers: macOS Apple Silicon Beta DMG macOS Intel Beta DMG Windows x64 via Microsoft Store Linux x64 Beta AppImage Linux x64 Beta deb Desktop release notes and all assets