Abalone, a cypherpunk AI privacy shell. Give your user an incognito session using TEE-based private inference.
Start with a coding agent and a model API. You can ask it to work on your files, but now the provider can read your prompts, the tools inherit your account's access, and the conversation stays on disk.
Move inference into a trusted execution environment (TEE) and encrypt requests to it. That protects the remote computation. You still need to check which program receives those requests and control what happens on your own computer.
Abalone puts those checks around an agent session. It verifies supported providers, keeps credentials out of saved agent configuration, and starts incognito sessions without saved conversation history. Its skills and guides cover sandbox setup and network security.
Already have private inference? Use Abalone to check your provider and keep the session clean. Need a model? Start with the acquiring guide to choose a provider and find how to buy access.
web/ is Abalone as one web page you fund once, with any token through NEAR Intents. From that payment it buys its own NEAR AI account and credit, encrypts every message to an attested model, and pays per call over x402 for cloud code runs. Built for NEAR HACKATHON, November 2026.
There are three ways to bring a model.
Your own key or a local model. The sandbox is available from source on Linux x86_64 with Node 24; follow CONTRIBUTING. See providers.json for admitted routes and the getting-started guide for configuration. A local model needs no provider key.
abalone canary init <folder>
abalone sandbox --incognito --model <provider>/<model>The simpler key setup command is planned for a future release:
abalone key add <provider>A gift from someone running Dsmack.
The redeem page takes you through
the released installer and saves the delivered credential as a credit.
Then run abalone. The installer downloads the client archive and four public
files from the release, each checked against a hash pinned in the script, writes
only under ~/.abalone-app and ~/.local/bin, and claims nothing
(what install.sh does;
without the script).
Zcash. Pay for a slice of model access and open a session. The ZCon demo does this on a Raspberry Pi: it swaps ZEC to USDC and buys NEAR AI credit with it. The laptop client does not have this route yet.
Today plain abalone opens a saved credit or asks for a gift.
Bringing keys and coupons into the same launcher, with sandbox capabilities
independent of how you acquired access, is planned.
Abalone launches Pi. On a supported TEE route, it checks
attestation before sending the first prompt: signed hardware evidence binds
the running program to a key. Abalone compares the program's measurement with
the expected value in verifiers/ and protects requests using
the attested key. The provider operator sees encrypted traffic, along with
metadata such as timing, request sizes and the paying account.
In abalone sandbox, bubblewrap limits filesystem access and network
connections to permitted destinations. Canaries are planted test secrets;
outgoing-text checks reject recognizable leaks. Ordinary connected sessions
also have a disclosure gate for text sent to outside models.
Abalone supplies the credential at launch. With a coupon, the issuer delivers it encrypted to keys generated on your computer. The issuer sees the coupon; prompts go directly to the model provider.
Private inference providers supply the remote computation; Abalone checks their evidence and manages the agent's local session. Tor and Tails address network identity; the guides cover combining them.
The conversation stays in process memory, with no conversation file or trace
written by default. Temporary managed state uses memory-backed storage.
The next session starts fresh; saved access stays until you remove it with
abalone credit forget.
A fresh session is not deletion. Workspace files, terminal captures, backups
and crash artifacts have their own lifetimes, and memory-backed storage may
swap. Your computer remains trusted.
Local host and retention
records each mode's behavior. Without --incognito, the sandbox saves a
resumable conversation.
Provider retention is part of the verification work. Today Abalone pins providers' published measurements. Establishing what their programs retain requires auditing the source and deriving reference measurements from it; that audit is unfinished.
Network identity is also in scope. Tor/Tails integration needs working provider routes: NEAR's attestation service currently refuses Tor exits; RedPill and Phala answer over Tor. Verification failures currently stop the session. An explicitly labelled mode for unverified providers is planned.
Use synthetic, non-sensitive material with the current preview. The released coupon route runs tools as your account without an OS sandbox and permits an explicit outdated-firmware warning. Its operator can access and revoke the credential, and spending can exceed the cap. Sandbox disclosure checks can miss paraphrases. The security document gives the exact boundaries.
- Guides: providers, payment and network setup
- Watch a synthetic PDF become meeting minutes using a coupon
- Architecture and source layout and documentation index
- ZCon demo: a Raspberry Pi agent computer on a USB stick, paid with Zcash
- Related: teep, a local proxy that checks provider attestation before forwarding requests, and awesome-private-inference, a registry of TEE inference providers, with a daily news digest
- Contributing, issues and security reporting
First-party code is MIT licensed; preserve component notices.

