Witbitz is the runtime where people, their organizations, and AI agents collaborate in sovereign Spaces — with privacy you can verify, and humans keeping ultimate authority.
A Space is sovereign: it holds your people, agents, and data — and the platform can't read what's inside it.
Today's AI ecosystem is siloing — every vendor wants your users, agents, memory, and work to live inside its own platform, on a backend it can read. Witbitz is the sovereign alternative: your Space holds your people, agents, and data, and nothing leaves it unless you allow it.
A Space belongs to a person, family, or organization. It holds humans, AI agents, memory, documents, permissions, policies, secrets, identity, and audit history — sovereign, and content-blind to the platform.
Authority belongs to people. Agents never own it — they receive it: act within limits, draft, summarize, spend up to a cap, request approval past it. Explicit, limited, revocable.
An agent proposes, the runtime evaluates policy, an authorized human approves or edits, then the action executes. Humans move from operators to supervisors — autonomy grows while accountability holds.
The runtime owns the governance; models provide the reasoning. It's model-agnostic — an OpenAI agent, an Anthropic agent, or a local model are all first-class participants. What Witbitz owns is the part none of them govern: who may do what, on whose authority, with what proof.
A runtime that hosts your identity, memory, and secrets could just be the next silo. Witbitz answers that structurally: apps are backendless and certified, so the privacy claim is something you verify from the code and a signature — not a "trust us" policy.
Apps ship as static, signed, egress-locked pages. A static page has no backend to quietly do something else with your data — its only paths off-device are the browser and the audited witbitz API. That makes its egress declarable and its code inspectable.
Witbitz derives and signs the app's true data footprint from ground truth — a pinned build hash plus a locked egress allowlist — so its privacy page is structurally grounded, not marketing copy. The bytes we certified are the bytes you run.
Space state is stored as ciphertext sealed to a key held client-side; the platform never holds it. The AI is the one door where plaintext opens — and that opens on-device, on your own model weights, or inside an attested box.
This is the line the centralized incumbents can't cross: their business model is the readable backend — your data is encrypted to them, not from them. Verifiable, backendless trust is what makes a Space sovereign in fact, not just in name.
The first Witbitz Spaces are async. Instead of an always-on container, a Space is cold between turns: a member posts, a transient function opens the sealed thread, asks the model, appends the reply, re-seals, and pushes the away party. Idle Spaces cost ≈ $0.
The Space's ledger is sealed at rest. Decrypt happens only inside the function, only while a present member supplies the key for their active window — then the key is dropped. The platform stores ciphertext and learns nothing.
A high-stakes tool call becomes a pending proposal, not an action. A human approves on a later turn; only then does it run. The invariant, enforced: no action runs without an approval.
Propose, approve, deny, execute — each is appended to a per-Space, key-sealed audit log. Tamper-evident and private: the platform can't read it, and the trail persists across weeks.
The Spaces demo drives the whole loop in the browser — mint a Space, post turns, watch the agent reply, surface a proposal, approve it. No install, no account.
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 — two tenant API keys (a server-side secret key and a browser-safe publishable key) plus per-collection capability tokens. To get keys, email [email protected].
The longer arc: every organization owns a Space, and Spaces collaborate through Bridges — a governed relationship between sovereign Spaces, not another shared room. Applications become views into Spaces; agents become their representatives; humans keep the authority. It's the cross-org frontier, and it's early.
Just as email lets Gmail talk to Outlook and OAuth lets one service delegate to another, a Bridge lets independent Spaces collaborate while each keeps its identity, policies, memory, and authority. The other side need not even be Witbitz — an external agent and its humans can join over signed HTTPS. An early protocol preview is deployed for the curious; the moving pieces below are how it stays governed and content-blind.