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.
Because the app talks only to Witbitz, its entire data footprint is declared — which is what makes its privacy verifiable.
Everything happens in a Space — a self-authenticated room that carries its own identity, members, and permissions. Around it, Witbitz is three layers.
How humans and AI meet. Today Witbitz supports live calls and async spaces — with more modes to come.
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.
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.
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.
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.
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.
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 exactly one place — the AI turn, running the declared program — and closing that door too is the attested tier.
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 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.
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.
The account-free link is great UX, but a URL is a poor key vault — easy to copy, screenshot, sync, or lose. The Companion is one native app, installed once, that carries the things a static page can't — your keys, your recovery, your notifications — for every Witbitz app, and is the one device-side runtime we certify.
Not localStorage, not a link you can screenshot or sync by accident. The secret stops
riding the URL.
Receive re-keyed epochs without re-sharing a link, and hold your own recovery — a code or k-of-n social recovery. Never an operator key.
One app reaches you for every Space — no install-per-app. Content-free, sealed endpoints.
Honest scope: the Companion closes the peer half — agent turns still run on server compute until the attested tier — and it's designed, not yet shipped (interim: content-free Web Push). Read the design →
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 humans and an AI in one shared room — the multiplayer ChatGPT above.
An AI with tools into the company's systems, talking under company governance — designed so the org can't read individual sessions at rest.
A professional and an AI both serve the client in a shared room — and strategize or evaluate in a private back room.
Each side keeps a private room with its own data and agent, then meets in a shared room, revealing only what's approved.
One subject's Space that several orgs connect into, each keeping its own data, the person owning the through-line.
A personal Space + agent that knows you and joins other interactions with scoped, revocable permissions.
Everything is JSON in, JSON out, over HTTPS, tenant-keyed. The contract is open and machine-readable; access is invite-only during private beta.
| Endpoint | What it does | Auth |
|---|---|---|
| GET /catalog | The public agent catalog | publishable |
| POST /collections | Create a collection — items, curation, artifacts, a keyless render page | secret |
| POST /sessions | Launch (or re-summon) an agent — metered, idempotent | secret |
| POST /wallets/grant | Fund an agent session from a wallet | secret |
| GET /collections/{id}/render | Keyless share page for published content | public |
Access. Invite-only during private beta — a server-side secret key and a browser-safe publishable key, plus per-collection capability tokens. Email hello@witbitz.chat. · Connecting Spaces across organizations is an early Bridge protocol → preview.