One platform. Two deployment models.
Cuitty Cloud or self-hosted — the same Rust + TypeScript stack, the same wire protocol, the same sixteen Observe modules. You pick where it runs.
$ curl -fsSL https://cuitty.com/install.sh | shCuitty Cloud
Identical software. Identical architecture. We run the boring parts so your platform team can ship instead of patch.
Zero-ops is a real feature.
We run Postgres, SpiceDB, the libSQL replicas, the audit-chain notary, and the upgrade pipeline. You write code.
US, EU, AP — region-pinned.
Pick your region during onboarding. Data never leaves it. Cross-region replication is opt-in and audited.
Weekly transparency log.
Your audit chain gets notarized into a public Merkle log every Sunday. Tamper-evidence without doing the cron yourself.
Hosted packages, scans, and storage.
We run Cuitty Registry endpoints for npm, Cargo, OCI, and PyPI, plus artifact storage, SBOM generation, scans, and index rebuilds.
Managed app runs.
Cuitty Cloud operates the Airflow jobs for app installs, app events, package publishes, ownership transfers, and cleanup.
Private uplink to your infra.
Wire Cuitty Cloud into your VPC over private networking by request. No public ingest required.
What we run for you
- All production modules
- BetterAuth + SSO (SAML/OIDC) supported
- Hourly snapshots, 30-day rolling restore
- Audit-chain notarization
- Hosted Cuitty Registry and Code App Market
- Managed Airflow for app and package workflows
- Managed SpiceDB authorization graph
- Region-pinned data residency
- Support coordinated by request
Self-host
The whole stack comes up with one command. Docker Compose, Kubernetes, or a single binary — your hardware, your data, same modules.
$ curl -fsSL https://cuitty.com/compose.yml -o compose.yml
$ docker compose up -d
# Upgrade:
$ docker compose pull && docker compose up -d- Postgres, SpiceDB, Airflow, object storage, Code, Registry, the API, the dashboard
- Single network, single volume root
- Upgrade with docker compose pull && docker compose up -d
Hardware sizing
| Tier | CPU | Memory | Storage |
|---|---|---|---|
| Laptop / demo | 2 vCPU | 4 GB | 10 GB |
| Small team (10 users) | 4 vCPU | 8 GB | 50 GB |
| Medium org (50 users) | 8 vCPU | 16 GB | 200 GB |
| Large org (500 users) | 16 vCPU | 32 GB | 1 TB+ |
Cloud vs self-host
Both options run the same modules and the same protocol. The difference is who operates the infrastructure.
| Feature | Cuitty Cloud | Self-host |
|---|---|---|
| Software | Identical | Identical |
| Modules | All production modules | All production modules |
| Auth (SSO) | Supported | Self-managed BetterAuth |
| Backups | Hourly snapshots, 30-day restore | DIY (cui backup) |
| Upgrades | Managed, zero-downtime | Pull and restart |
| Region pinning | US, EU, AP at onboarding | Your infrastructure |
| Support | Supported by request | Community (Discord, Discussions) |
Architecture internals
Products, surface, Observe modules, auth and RBAC, ingest, storage, and
the Rust runtime. Every layer is replaceable; the wire protocol is the
contract between them. Self-host runs the same stack as Cloud — the only
difference is who calls docker compose up.
Cuitty ships nine products: Code, Store, Safe, Registry, Architect, Observe, Pilot, Video, and Scrape. They share auth, ingest, and storage layers below.
The portal UI is one entry point. llms.txt and a roadmapped MCP server are the others. Every doc page and module lives behind a single addressable surface for humans, agents, and CLIs.
Sixteen production modules -- each with its own libSQL database, its own schema, its own ingest path. Turn them on independently. Same auth, same RBAC, no monolith.
BetterAuth handles sessions, OAuth, magic links, and passkeys. SpiceDB handles relationship-based authorization. Every module reads the same identity; every API call hits the same policy plane.
Everything is a signed POST to /api/ingest. The SDK is a convenience, not a requirement. cURL works. Each event is verified at the edge before it lands in the owning module's database.
Each module owns a libSQL file -- its own schema, migrations, and audit chain. Shared Postgres backs auth, RBAC, and cross-module workflow state. No single database is the bottleneck.
Bun on the server. Docker Compose on a laptop, a VPC, or our cloud. No Kubernetes required, no proprietary control plane -- the whole stack starts with one command.
Choose your deployment model
Compare Cuitty Cloud and self-hosted deployment in the documentation.