Products, without the maze.

Teams surrender code to SaaS forges or run half-finished self-hosted alternatives without real CI, authorization, or extensibility. CI minutes are opaque and runners proprietary.

Full Rust (Axum, git2-rs) forge with repos, PRs, issues, and forking. CI runs on Apache Airflow + Dagger containers with SpiceDB (Zanzibar) authorization and storage delegated to Store.

• ~200 API routes on a Rust core
• 44 Solid UI islands (DiffView, CommitGraph)
• Embedded package registry (npm/Cargo/PyPI/OCI)
• App Market for versioned automation
• Airflow+Dagger CI pipeline
• SpiceDB branch protection
• Ratatui TUI
• Yapture issue sync

• ✓Infrastructure ownership: hardware, minutes, secrets
• ✓Sub-ms ref ops with portable CI
• ✓Zanzibar permissions without middleware
• ✓Unified audit trail via Observe
• ✓No vendor lock on CI runners

Observability fragments across SaaS tools with separate logins, billing, and no shared context. Self-hosted options are one-size-fits-all.

16 purpose-built modules behind one /api/ingest, one libSQL database per module, shared Auth/RBAC. Every Cuitty product emits into it automatically.

• 16 modules with dedicated DBs
• Single ingest endpoint, batched fire-and-forget
• OTLP-compatible traces with flame graphs
• Fingerprinted error grouping
• Feature flags with rollouts and kill-switches
• Cloud cost tracking (GCP/AWS/DO/Azure)
• Polyglot secret scanner
• Wire protocol: 22 channels, 28 schemas

• ✓Single pane for security/platform/observability
• ✓Per-module DBs eliminate noisy neighbors
• ✓Telemetry never leaves your infra
• ✓Flags and audit included out of the box
• ✓TS/Go/Py/Rust SDKs

SQLite/Postgres/S3/Redis each demand separate SDKs, migrations, and error handling. Switching providers rewrites data code.

One createStore() API with 24 storage-class accessors, offline-first with CRDT/LWW sync, profile routing across 65+ adapters, E2E encryption by default.

• 24 accessors (table, kv, cache, queue, vector, graph)
• 65+ drivers incl. AWS/GCP/Azure, Solana, libp2p
• AES-256-GCM envelope encryption
• Automatic conflict resolution (CRDT/LWW)
• Config-only provider swap
• Portable archive import/export
• Rust bridge API

• ✓Instant offline reads
• ✓True vendor portability
• ✓Zero-knowledge encryption
• ✓One SDK for every data shape
• ✓Graduated local-to-cloud migration

Raw secrets leak into .env, CI configs, and generated code. Provider switches rewrite integrations.

Commit stable references (cuitty-safe:account/safe/secret); resolve at runtime from inline-encrypted, local vault, Store-backed E2EE, or 1Password. cui safe run injects at process boundaries.

• Vendor-neutral reference grammar
• 4 storage modes (inline, local, Store, 1Password)
• Native broker with OS key custody
• Provider delegation and migration
• No-leak gates on value paths
• TS/React/Solid/Go/Py/Rust/shell SDKs
• Desktop surface integration

• ✓Secrets never in logs, traces, or screenshots
• ✓Provider-agnostic secret management
• ✓Minimal blast radius on compromise
• ✓526 tests green (180 native + 346 SDK)

Third-party registries mean outages, policy risk, and per-seat pricing you don't control.

Standalone Rust service with native protocol endpoints (npm, Cargo sparse, PyPI Simple, OCI), persisting via Store's bridge API. Optional Code integration for provenance.

• 4 native protocols, standard tooling publishes
• Standalone operation (no forge required)
• SpiceDB namespace/package permissions
• Safe-backed config references
• Outbox-driven index rebuilds and replication
• Quotas, rate limits, scoped tokens

• ✓npm/cargo/twine/docker push just work
• ✓Artifact sovereignty on your infra
• ✓Protocol-native audit trail
• ✓One registry for all ecosystems

Provisioning spans 7+ clouds with per-provider tooling. Terraform runs are manual, drift undetected, changes unaudited.

Unified Rust control plane: provider catalog, plan/apply/destroy lifecycle, drift detection, GitOps promotion (local to staging to prod), all emitting audit events to Observe.

• 7 providers (AWS/GCP/DO/Civo/Vultr/Hetzner/CF)
• Plan/apply/destroy lifecycle engine
• HCL overlay generation
• Airflow/Dagger pipeline dispatch
• Ephemeral PR environments
• CLI/TUI and 22 API routes

• ✓One interface per cloud
• ✓Drift caught before users notice
• ✓Atomic audited promotions
• ✓No zombie infra
• ✓Full audit trail via Observe

Dashboards without API coverage force manual clicking. Recorded flows break when selectors drift.

Playwright engine records workflows as YAML/DSL playbooks, replays deterministically, heals by AI. 6 executors (browser, git, http, shell, persist, terraform) orchestrate beyond the browser.

• 17 SDK packages
• AI selector healing
• Recording to draft playbook conversion
• Video capture with redaction
• SSE live progress streaming
• Multi-language clients (TS/Go/Py/Rust)
• 11 Solid components
• Bounded AI decisions + review summaries

• ✓Automate where APIs fall short
• ✓Self-healing cuts maintenance
• ✓Full video audit trail
• ✓Extensible executor model

Demo and marketing video drifts from the product and can't be regenerated when UIs change.

TypeScript composition API + YAML/DSL. Frames render as HTML in headless Playwright, FFmpeg encodes MP4/WebM/GIF. HTTP render server makes it CI-pipeable.

• CompositionIR with tween/spring/keyframes
• Playwright+FFmpeg render pipeline
• <cuitty-player> Web Component
• Full DSL roundtrip
• CLI (init/render/preview/validate)
• Render server with queue + SSE
• Solid editor (timeline/preview/inspector)

• ✓Pixel-perfect CSS/SVG output
• ✓Videos regenerate with UI changes
• ✓Batch render in CI
• ✓One composition, three formats
• ✓Hot-reload preview

Scraping means fragile selectors, browser state management, auth handling, and layout drift.

URL + plain-text intent triggers Playwright render, producing Markdown view (content) + DOM view (interaction). Returns an immediate answer AND a reusable, self-healing scraper artifact (DSL block). Auth delegates to Safe; human-in-the-loop gates for CAPTCHA/MFA.

• Paste-and-describe interface
• Dual-view engine (Markdown + DOM)
• Answer + artifact per job
• AI healing (Claude via Vercel AI SDK)
• HITL interaction gates for CAPTCHA/MFA
• Embeddable createScrapeServer
• Extracted from Pilot with HTTP-only boundary

• ✓No selector maintenance
• ✓Deterministic replay of scraper artifacts
• ✓No credential sprawl (Safe-backed)
• ✓Embeddable by Tests/Pilot/third parties

Docs tools are either rigid site generators or heavyweight CMSes; embedding docs in an app means a second stack.

One pipeline produces site, embed, and headless output. All editing surfaces are Cuitty Editor. Themes derive from brand tokens with family and sub-theme cascade.

• Content model with multi-format adapters
• Portable output: site, embed, headless
• Auto dictionary with contextual tooltips
• Page modes: doc, blog, status, changelog
• AI summary and social card generation
• Theme families with sub-theme cascade
• Per-property generated CLI/TUI (clack + OpenTUI)
• Self-hosted admin CMS with audit and presence

• ✓One source, three targets
• ✓Zero separate editing stack
• ✓Brand-consistent theming out of the box
• ✓Social cards generated, not hand-crafted
• ✓Full audit trail via Observe