Build apps and AI agents on Gora

Deploy your program and UI, give agents unique identities, and connect structured AI to testnet transactions.

Build apps and AI agents on Gora

Deploy your program to Gora, request structured AI results, and use them in your own app. Host the UI on your website or deploy it with your Gora package. Users can open it in a browser or through Gora Explore.

Start with the Base/Solana app quickstart, then read agent identity and signing and AI credits. These separate identity, inference payment and transaction authority; none implies the others.

This phase uses a managed VM for execution, hosting and provider credentials. Validator stakes and replay signatures are real, but managed agent-wallet custody is not independently distributed or trustless. Source support, live activation, functional acceptance and App Store approval are separate launch gates.

The Gora testnet is live. You develop on your own machine with the gora CLI and deploy to the public testnet endpoint — no VM, no local chain stack, no tunnels:

Your machine: gora CLI + your app code
        ↓  deploy / invoke over HTTPS
Gora testnet: validators, app registry, execution, attestations
        ├─ Algorand: gateway/vault callbacks → app contracts
        ├─ Base Sepolia: approved managed agent → app contracts
        └─ Solana devnet: approved managed agent → app programs

There are two kinds of apps you can build today:

1. Off-chain apps that live on Gora. Your code is deployed to the network, invoked on demand (or on a schedule), and returns signed, attested results. No smart contract required.
2. Off-chain apps that serve smart contracts. Your app proposes a chain action after execution. Algorand uses the gateway/vault path; Base/Solana use separately approved managed agent signers. Execution signatures and confirmed chain delivery are separate evidence.

Quickstart — deploy your first app in 5 minutes

Everything below runs against the live testnet endpoint https://gora-bridge.74.241.248.103.nip.io.

# 1. Install the CLI (one line — downloads a prebuilt binary)
curl -fsSL https://gora-bridge.74.241.248.103.nip.io/install.sh | sh
export PATH="$HOME/.gora/bin:$PATH"
# (No prebuilt binary for your platform? The installer prints the source-build
#  fallback: git clone … && cargo build --release -p protocol-core --bin gora)

# 2. Create an app — pick a unique name, app ids are global on the shared testnet
gora init hello-alice --language wasm --chain algorand --app-kind offchain-only --yes
cd hello-alice

# 3. Point the CLI at the live testnet and set your developer token (= your identity)
gora config set node.url https://gora-bridge.74.241.248.103.nip.io
openssl rand -hex 32 | gora config set api.token --stdin

# 4. Build, deploy, invoke (the app id is your app name with dashes → underscores)
gora build
gora deploy .
gora invoke --app hello_alice --input fixtures/request.json

The starter is a real WASM app (not an empty stub): it reads your request input, keeps a per-app counter in durable state, and echoes both back — so your first invoke returns 1 … and the next 2 …. Edit src/program.wat to make it do what you want (the commented llm/http_get imports turn it into an agent or oracle — see the WASM runtime reference).

The invoke response contains your app’s output, the billing settlement, and the state root before/after execution. To ship a change: edit the app, set a new version_label in gora.app.json, and run gora deploy . again.

If gora deploy fails with only the current owner may publish an upgrade, someone else already owns that app id — pick a different app name. upgrade must publish a new version label means it is your app: bump version_label.

Two things to know: the public runtime runs WASM; your frontend can use JavaScript. Your developer token owns your deployments and must never enter browser code. Execution and AI use bounded testnet credits; consult the live billing policy rather than assuming unlimited free inference. GORA staking and native-chain fees are separate balances.

What to read

Goal	Page
Endpoints, contract IDs, what’s live	Connect to the testnet
Understand the system	How Gora apps work
Create an app (all templates)	Create a Gora app
Deploy and operate your app	Deploy to Gora
Serve a smart contract with data	Smart-contract callbacks
Add or resolve chain contracts	Add chain contracts
Build an app that holds value on-chain	Build an attested on-chain app
Rebuild a working reference app	Examples
WASM ABI, host functions, limits	WASM runtime reference
Ship a web UI with verified sign pop-ups	Web UI and verified signing
Configure permissions and payments	Set policy and payments
Understand validators and consensus	Validators and consensus
Run everything locally instead	Local devnet quickstart
Fix common problems	Troubleshooting

Safety rules

• Gora app code returns JSON; it should not hold private keys.
• gora deploy deploys the Gora app package, not chain contracts.
• gora contract deploy --node <url> resolves or records chain contract metadata from the Gora node.
• Chain execution happens through a gateway, wallet, contract, mobile signature, or submitter.
• Testnet keys and mnemonics are for testing only. Never reuse them on mainnet.