Build privately. Here's how.

AzraCode is a peer-to-peer sealed AI building protocol. You submit a build, it runs inside a hardware-enforced enclave — encrypted in, sealed execution, encrypted out — and you get a finished artifact back. The node operator never sees your input or output.

There are three ways to use it, all backed by the same sealed compute:

• CLI — pipe a workflow straight into a sealed build.
• Studio — a visual workspace with live preview and diff review.
• Web App — submit builds and manage $AZRA from the browser.

The fastest path is the CLI:

# install
npm i -g @azracode/cli

# connect your wallet (keys stay local)
azra login

# run your first sealed build
azra build --sealed ./src/auth.ts

The CLI is the zero-UI, maximum-speed surface. It encrypts your payload locally, routes the ciphertext to an attested node, and returns the re-encrypted artifact.

azra build --sealed ./src/auth.ts

# encrypting payload…
# routing to attested node 0x8a3f…b29e
# sealed execution ✓
# artifact returned · -3.0 $AZRA burned

Common flags:

• --sealed — run inside a sealed enclave (required for private work).
• --diff — return changes as an in-editor diff instead of writing files.
• --out <dir> — write the decrypted artifact to a directory.
• --attest — print the attestation quote for the run.

Settlement is automatic: each build burns $AZRA, and you'll see the amount in the run summary.

Studio is the visual workspace. It pairs a file tree with a diff viewer and a live preview, so you can orchestrate changes across multiple files and review every edit before it lands.

The typical flow:

• Open a project — files are encrypted client-side as you work.
• Describe a change; Studio returns a diff across the affected files.
• Review additions and removals inline, with a live preview of the result.
• Accept to apply, or refine and re-run — all inside the seal.

Because the build runs in a sealed enclave, your source is decrypted only inside the boundary and re-encrypted on the way out.

The Web App lets you submit builds, track artifacts, and manage your $AZRA balance from the browser — no install required. Open it at /app.

• Submit a sealed build from a path or prompt.
• Follow it live through the pipeline: encrypting → executing → sealed → done.
• See balance and burned $AZRA update as builds settle.

The preview workspace is fully on-site; the production app adds wallet connect and on-chain settlement.

Sealed execution

A hardware-enforced enclave where your data is decrypted, computed, and re-encrypted without the host being able to read it. The operator hosts the cage but holds no key.

Proof-of-compute (attestation)

Each enclave emits a signed measurement of its exact code and hardware. Verifiers check it before a reward settles — proving the work happened without revealing what it was. See the Protocol page for detail.

Burn-to-Build

Each build burns $AZRA; each verified compute mints $AZRA to the provider that ran it. Supply follows real usage rather than an emission schedule.

Can the node operator see my data?

No. Input is encrypted on your device and only decrypted inside the enclave. The operator can see that a job ran and what it settled — never the contents.

What does attestation actually prove?

That a genuine enclave ran the exact, unmodified runtime. It does not prove the code is bug-free — which is why the runtime is open to review.

What happens to my data after a build?

The artifact is re-encrypted to your wallet key and returned; then the environment is destroyed — memory zeroed, state wiped. Nothing readable persists.

Which chain does settlement run on?

Solana. $AZRA is an SPL token used to settle sealed compute.