AsiaGPU documentation

Getting started

1. Create an account. You get a workspace; invite your team under Team (they get an email with a link that works only for their address).
2. Under Settings → Data location, choose where chats and files are stored: a data centre in your country, or your own server.
3. Under Deploy AI, pick a model, tick the functions you need (Documents, Voice, Pictures, Data & files, Web search) and where it may run. You land in the chat screen while it starts: about a minute once a server has run that model before, a few minutes the first time.

Data sovereignty

Three things decide where your data goes, and you control all of them:

• Where the model runs. Your own machines (Private), verified data centres (Sovereign) or the open marketplace (Community). Set a workspace rule under Settings → Where AI may run; it is checked for every deployment, task and app before anything is sent to a machine, and work already running somewhere the rule no longer allows is stopped. A workspace with its own private server only ever runs there: if that server is busy or offline, work waits rather than moving.
• Where chats and files are stored. In the data vault your workspace chose, and end-to-end encrypted: your browser locks them with your workspace's key before they're sent, so the vault (and we) only ever hold locked data. Members get the key from an admin's browser; the workspace's recovery code is the way back in if passwords are forgotten. Nobody else can recover it.
• How data travels. Your browser talks to the model and the vault, over HTTPS. Prompts, documents and answers never reach our control servers. On rented GPUs they do pass through our gateway (see below); on your own servers in private mode they don't.

Who can see your data

Encryption protects your chats and files while they are stored. It can't protect them while the AI works on them: a GPU has to read your question, document or recording to answer it. So at that moment, whoever controls that machine could copy it. This is the honest picture:

Our software never writes your prompts or files to a GPU machine's disk or logs, and erases task folders. But software on a machine can't stop that machine's own administrator. A dedicated GPU keeps other renters away from your work; it doesn't keep the host out. The Sovereign tier lowers the risk (known operators in known places), but you still trust that operator. None of the tiers uses confidential-computing hardware that would keep the operator out. For data that must stay confidential, use your own server.

Also worth knowing:

• Our website runs in your browser. The page that locks your data is served by us, so you trust us not to change it to send keys elsewhere, and to tell your browser the right keys: the machine's when a task starts, and each new member's when an admin's browser hands them the workspace key. On an AsiaGPU Box the page and those keys come from your own server.
• Some functions go outside. With the Telegram bot, messages pass through Telegram. Web search sends your search words to public search engines. Invitation and password-reset emails go through an email provider (they don't contain your chats).
• Keys can't be taken back from someone who copied them. When a task ends, we delete the folder's locked key and the storage server refuses that task's passes within a minute. When a member leaves, their passes stop working too. But a machine or person that already copied a key or a file keeps it: folder and workspace keys don't change afterwards. Removed members also keep any running deployment's key and app links they saw, until those are restarted.

Chat, documents and pictures

Open Chat from the sidebar. Attach files with 📎, paste or drag them in. Short documents are read in full; long ones are split and searched for the parts relevant to each question. Pictures need a vision model (Qwen3-VL) with the Pictures function. With Qwen3 8B, the 💡 Think switch makes the model reason step by step for harder questions.

Voice, pictures and video

With the Voice function, press 🎤 to speak instead of typing and ■ Stop when done: your words are transcribed by Whisper on your own GPU, in 90+ languages, and placed in the message box for you to check. With Natural voice too, Read aloud under an answer speaks it in a natural, human-sounding voice made on your GPU, and 🔊 Speak answers reads every answer as it arrives. It speaks Chinese, English, Japanese, Korean and six European languages; for other languages, and without the function, your device's built-in voices are used, so the text never leaves your computer.

To create pictures, deploy a picture model and describe what you want; a poster takes a few seconds. FLUX.2 klein also edits photos: attach one (or press Edit under a picture it made) and say what to change, such as “make the background white”. To make videos, deploy Wan 2.2 and describe a five-second scene, or attach a picture to bring it to life; a video takes a few minutes. Pictures and videos are saved in your data location with the chat, never on the GPU server.

Data analysis, files and web search

With Analyse data & create files, attach a spreadsheet (Excel or CSV) and ask for totals, trends or a chart: the model writes Python, runs it and explains the result. Ask for a file and you get an Excel, Word, PowerPoint or PDF file to download. The code runs inside your own browser, so your files never leave your computer for it; open Ran Python above an answer to see exactly what was run.

With Web search, the model looks up recent facts and cites its sources. Searches run through SearXNG, an open-source search engine on the GPU server: only the search words go out to public search engines, never your files or chats.

Assistants and knowledge

Upload company documents once into a knowledge base (Knowledge in the sidebar): HR policies, product manuals, contracts. Then create an assistant (Assistants) with its own instructions and the knowledge bases it may use; templates (HR helper, contract reviewer, customer support writer) get you started in seconds. Your team picks an assistant in the chat sidebar and asks away: the assistant finds the relevant passages and says which document they come from.

Admins and owners can share knowledge bases and assistants with the whole workspace; anyone can make private ones for themselves. Both are stored encrypted in your data vault. Adding documents to a knowledge base needs a running deployment with the Documents function, which prepares them for search.

Files and GPU tasks

Files keeps your files in folders: recordings, scans, datasets, notebooks, trained models. Like chats, they're locked in your browser before they're stored.

Recordings get a Turn into text button and scans or PDFs a Read the text button: the text appears in the same folder a few minutes later. For developers, More → Developer tools opens Jupyter notebook, Fine-tune a model (Unsloth Studio), ComfyUI and VS Code on a folder, in your browser.

When a task or tool starts, your browser hands the folder's key to that one GPU machine, locked so only it can use it. The machine puts the project's files in an encrypted folder whose key exists only in its memory. New and changed files are saved back to Files every few minutes and when the task ends; then the folder is erased, which makes whatever was on the disk unreadable. You pay for the GPU while it runs, not while it saves.

If saving fails (the storage server is offline or full), the machine keeps trying every few minutes. The task shows when its unsaved files will be erased, and whoever started it gets an email after half an hour. Fix the storage server in that time and nothing is lost. A rented machine keeps unsaved files for 24 hours, then erases them: keeping your data on someone else's machine longer is the bigger risk there. Your own servers keep them for 30 days (the saveFor setting in the agent's config changes this). Work saved every few minutes while the task ran is always in Files.

Sharing a GPU

Unless you tick A whole GPU to itself, a deployment books only the GPU memory it needs, and other deployments (possibly other customers') can use the rest of the card. What that means:

• Memory: each AI engine reserves its booked memory when it starts and keeps it. The engine itself keeps to that size; the GPU doesn't enforce it. Only the platform's own engines share cards: Jupyter, VS Code, fine-tuning and custom containers always get a whole GPU. So do Files tasks, unless Chat is running with what they need (documents, or voice for recordings): then they use Chat's engines, start in seconds, and need no GPU of their own.
• Speed: there is no guaranteed speed. Programs on one GPU take turns. In our test on an RTX 5090, one model answered at 149 tokens (word pieces) per second alone and at 71 while a neighbour handled 32 long requests at once: about half the speed, with no errors.
• Problems next door: when a neighbour's engine was stopped abruptly and restarted, the other kept answering throughout. That was tested with the platform's own engines. A program that ignores its share (only possible on hardware you control yourself) could still take memory from others.
• Privacy: deployments on one card run in separate containers and can't read each other's memory through our software, but they share one chip and one host. For confidential work use a whole GPU, or better, your own server (see Who can see your data).
• Price: the host's price for the card, times your share of its bookable memory.

On a 32 GB card (RTX 5090) only one AI fits at a time: Chat with documents and voice books 27.4 GB of the 29.3 GB that can be booked, a picture model 20–21 GB and the video model 27.7 GB. Asking for a second one is refused straight away with what is using the GPU, so you can choose what to stop; nothing running is ever stopped to make room. Developer tools need the whole card too. Files tasks run alongside Chat on its engines (they stop if Chat is stopped); without Chat they need the whole card. A 48 GB card holds two chat models (without documents and voice), an 80 GB card more.

Using the API

Every deployment is an OpenAI-compatible endpoint. Find its address, model name and key under Deploy AI → Use from your own apps.

curl https://<deployment>/v1/chat/completions \
  -H "Authorization: Bearer sk-..." \
  -H "Content-Type: application/json" \
  -d '{"model": "qwen3-vl-8b", "messages": [{"role": "user", "content": "Hello!"}]}'

Any OpenAI client library works: set its base URL to the endpoint and use the deployment's key.

SSH into a rental

Developers can open a terminal in a container they rent (Containers, and the developer tools: Jupyter, VS Code, ComfyUI, fine-tuning). Add your SSH public key under Settings → Your SSH keys, then run the command shown next to the running rental:

ssh -p 31234 3f2b6c1e@gw.example.com      # a rental through the gateway
ssh -p 2222 3f2b6c1e@10.0.0.5               # on a private-mode server: the server itself
ssh -p 31234 -L 8888:localhost:8888 3f2b6c1e@gw.example.com   # forward a port of the container

Nothing needs to be installed in the image: the GPU machine's agent is the SSH server and runs your session inside the container, as root, with bash when the image has it. The keys that open a rental are those of the workspace's owners and admins. The host key shown is the machine's own: the gateway only relays bytes, so the session is end to end between you and the machine. Files: scp works when the image has it; otherwise tar over ssh. SFTP isn't available yet.

A container's files

A container gets a disk at /workspace of the size you ask for (a reservation against the machine's free space, not a hard limit). Stop, keep files pauses the container: its GPU is released and no longer billed, and the files wait on that machine until you click Start again, which needs the same machine to be online with a free card. Stop & delete wipes them. Keeping files while paused is free for now. Everything outside /workspace is gone when the container stops.

Connecting your own GPUs

You need a Linux server with an NVIDIA GPU and its driver installed. Under My machines, click Add a machine and paste the command it shows on the server. It installs everything else (on Ubuntu or Debian, Docker and NVIDIA's container tools too), connects the machine and keeps it running as a service. The machine shows as online within a minute.

curl -fsSL https://<platform>/install-agent.sh | sudo bash -s -- --api https://<api> --token agr_...

Deploying on your own machines is free. The machine only computes: chats and files stay in your data location, and the AI engines don't write what users send to its disk. Without private mode, traffic to the machine goes through our gateway; with it (below), it doesn't. See the hardware each model needs; 200 GB of free disk is plenty.

Private mode

For servers whose data must never leave your network, add two options to the same command:

... --token agr_... --private --advertise-host 10.0.0.5

The server is never rented out, no traffic goes through our gateway (the agent refuses it), and container logs stay on the server. Models are reached at the address you advertise, on your network only.

When the site is opened over https://, browsers only call HTTPS addresses. Give the agent a certificate for the advertised address, and it serves the models and apps over HTTPS itself: --tls-cert cert.pem --tls-key key.pem.

AsiaGPU Box: everything on one office server

The whole platform on one GPU server in your office: the website, accounts, storage and the AI. Your chats and files stay in the building. On Ubuntu with the NVIDIA driver installed, get the AsiaGPU code onto the server and run:

sudo bash deploy/box/install.sh --email you@your-clinic.com --name "Your name"

It asks for the owner's password, installs what's needed and sets everything up (the first time takes about 20 minutes). Then:

1. On each computer that will use it, open https://<server>/ca.crt once and install the file as a trusted certificate (the installer shows how), so browsers trust the server.
2. Open https://<server>, sign in with the owner's email, and invite your team under Team.
3. Open Chat: the AI starts on the server's GPU.

Without the internet. While it still has the internet, the installer downloads everything these need, so they then work with the internet unplugged: signing in, the team, Files (upload and download), Chat with documents and voice, and the Files tasks (recordings to text, reading scans, invoices, summaries). These need the internet: web search, the Telegram bot, emails, AI models and developer tools not used before, and updates.

Forgotten passwords without email: an admin clicks Password link next to the person under Team and hands them the link. For the owner, run on the server: docker compose -p asiagpu-box exec api node dist/admin-cli.js reset-link EMAIL. After a reset, the person gets the workspace's locked chats and files back when an admin next opens the workspace (or with the recovery code).

Backups. sudo bash deploy/box/backup.sh FILE saves the Box into one file locked with a passphrase you choose: accounts, settings, files and the storage server's key. Keep it, and the passphrase, away from the server. On a new server with the same address, sudo bash deploy/box/restore.sh FILE brings everything back (it downloads the AI models again). Chats and files stay locked in the backup: they open again with members' passwords or the workspace's recovery code, as before. To update, run the install command again: data and accounts stay.

Running your own data vault

Under Settings → Add your own storage server, get a command and paste it on your Linux server, with the address your staff's browsers reach it at:

curl -fsSL https://<platform>/install-vault.sh | sudo bash -s -- --api https://<api> --token vtr_...   --url https://vault.your-company.com

With an https:// address (a name pointing at the server, ports 80 and 443 open) the vault gets its own HTTPS certificate and renews it. It backs up your data every day, keeping a week of backups in /var/lib/asia-gpu-vault/backups; copy them to another server too. Keep a copy of the vault.key file somewhere safe: without it, stored data and backups can't be decrypted. To restore, stop the vault and run asia-gpu-vault restore --from <backup file>.

Earning by hosting GPUs

1. Connect the machine (see above), then under My machines set its country and a price per GPU-hour. A machine with different cards (say a 5090 and two 3090s) gets a price per card model; renters see each model as its own offer, and work takes the cheapest card that fits.
2. Switch it to Public to list it on the marketplace. You receive 85% of what renters pay.
3. Under Billing, choose Wise or PayPal and add that account's email. You are paid weekly: every Monday 00:00 (Malaysia time, UTC+8) the week closes, and what you earned by then is sent the following Monday. Less than USD 20 carries over. Data centres can ask us to verify them for the Sovereign tier.

Teams, roles and activity

• Members chat with the workspace's models. Each person's chats are private to them.
• Admins also deploy models, manage machines and billing, and invite people.
• Owners also decide the data location, residency rules, payouts and other owners.

Every deployment, policy change, membership change and payout is recorded under Activity, exportable as CSV.