The trusted runtime

A runtime for humans, apps,
and AI agents to collaborate.

The internet was built for users and applications. The next generation needs a runtime where people, apps, and autonomous AI agents work together safely — under explicit permissions. Build your app as a static website with a verifiable privacy policy; Witbitz provides the identity, permissions, agents, storage, payments, and secure execution underneath.

✕  no other servers, trackers, or backends

Because the app talks only to Witbitz, its entire data footprint is declared — which is what makes its privacy verifiable.

Architecture

Three layers.

Everything happens in a Space — a self-authenticated room that carries its own identity, members, and permissions. Around it, Witbitz is three layers.

Layer 1

Interaction

How humans and AI meet. Today Witbitz supports live calls and async spaces — with more modes to come.

Layer 2

The platform

A general-purpose app backend: all of your app's flow, plus the AI that runs inside the app. It provides the runtime services every collaborative app needs.

Layer 3

The app

A static page with no backend of its own, connecting only to Witbitz. Not "no backend" — Witbitz is the backend (layer 2); you trade an arbitrary per-app server for one constrained, inspectable platform. One auditable trust surface is what makes privacy verifiable.

The platform provides
identitypermissionsagentsstorage paymentssecure execution
The trust model · the moat

Safe by construction: content-blind at rest, and the AI can't act alone.

Two guarantees make collaboration safe. First, privacy designed to be verifiable — headed for a signed proof, not a "trust us" policy. Second, humans keep the final authority over what any agent does.

One inspectable backend

No app-specific server to betray you

Apps are static, signed, egress-locked pages with no backend of their own — nothing to quietly do something else with your data. Witbitz is the backend, but it's a single constrained platform you can audit, not an arbitrary per-app server. You consolidate the trust surface to one inspectable thing; you don't remove it.

Verifiable

Verify the code, not the operator

The goal: Witbitz derives and signs the app's true data footprint from ground truth — a pinned build plus a locked egress allowlist — so its privacy page is grounded in fact, not marketing. The signed certificate is the in-progress north-star.

The double blind

Ciphertext at rest — even the owner is blind

State is sealed as ciphertext; the platform holds no key, and there is no operator recovery key. At rest, neither Witbitz nor the app's own owner can read it. Plaintext opens in one place — the certified render — which runs on the AI's turn and on every changed read. Closing that one door is the attested tier.

Humans keep the authority

Agents never own authority — they receive it. An agent proposes an action, the runtime evaluates policy, an authorized human approves or edits, and only then does it execute. Authority is explicit, limited, revocable, and every step is audited. Governance is the runtime's job; models just provide the reasoning.

The first app

Spaces — a multiplayer ChatGPT Live

The first app built on Witbitz is Spaces: a shared room where you and other people work with an AI together. Not a private one-on-one with a bot — many humans and an AI in one space, with tools that render as live widgets and a room that persists.

multiplayer chatan AI with tools + widgetsshared state async & offlineverifiably private

Open a Space and see for yourself

The demo runs the whole thing in your browser — a shared room, an AI that searches and builds live widgets, turns that persist. No install, no account.

Open the Spaces app →
No native app required

The browser already carries your keys, your reach, and the decrypt.

Everything a device-side “trusted runtime” was meant to add — notifications, durable keys, local decryption — an installed web app now does, on the same reproducibly-built, egress-locked page you can verify. No download, no app store, nothing to trust that you can't check.

Reach-me

Notifications, no app

Add a Space to your home screen and it reaches you with a content-free push — the device decrypts locally; the server learns only that something happened.

Yours to keep

Keys in a passkey, not a link

A hardware-backed passkey (synced by your provider) holds the secret, with an encrypted recovery you control — lose a link, still get back in.

Blind by design

Decryption stays on your device

The page decrypts in your own tab today; Sealed Spaces is the path to the key never reaching the server at all.

Still on the roadmap: an optional native Companion — more reliable background notifications and a Secure-Enclave keystore, for people who want it. A convenience, not a requirement. Read the design →

What you can build

The topology is the product.

Spaces connect in different shapes — one room, two sides, a hub, a crowd, a traveling agent. The valuable apps are the ones where the shape itself is the point.

Many players · shipped first

The Spaces app

Many humans and an AI in one shared room — the multiplayer ChatGPT above.

  • group trip planning
  • family financial council
  • community & co-op rooms
  • study groups
One governed room

An org's AI serves a person

An AI with tools into the company's systems, talking under company governance — designed so the org can't read individual sessions at rest.

  • customer service
  • bank / wealth advisor
  • telehealth intake
  • benefits navigator
Pro + AI, with a back room

Both serve a client, and confer privately

A professional and an AI both serve the client in a shared room — and strategize or evaluate in a private back room.

  • teacher + AI
  • doctor + AI scribe
  • lawyer + paralegal
  • therapist + AI
Two sovereign sides · the Bridge

Prep privately, meet in a shared room

Each side keeps a private room with its own data and agent, then meets in a shared room, revealing only what's approved.

  • negotiation
  • M&A data room
  • procurement
  • mediation
Hub & spoke

A person (or case) at the center

One subject's Space that several orgs connect into, each keeping its own data, the person owning the through-line.

  • care coordination
  • eldercare
  • estate planning
  • a learning record
A traveling agent

Your agent joins other rooms

A personal Space + agent that knows you and joins other interactions with scoped, revocable permissions.

  • personal assistant
  • shopping concierge
  • "represent me"
  • a personal health agent
API reference

The platform API.

Everything is JSON in, JSON out, over HTTPS, tenant-keyed. The contract is open and machine-readable; access is invite-only during private beta.

Platform API

tenant keys api.witbitz.chat/v1
EndpointWhat it doesAuth
GET /catalogThe public agent catalogpublishable
POST /collectionsCreate a collection — items, curation, artifacts, a keyless render pagesecret
POST /sessionsLaunch (or re-summon) an agent — metered, idempotentsecret
POST /wallets/grantFund an agent session from a walletsecret
GET /collections/{id}/renderKeyless share page for published contentpublic

Access. Invite-only during private beta — a server-side secret key and a browser-safe publishable key, plus per-collection capability tokens. Email [email protected].  ·  Connecting Spaces across organizations is an early Bridge protocol → preview.