> For the complete documentation index, see [llms.txt](https://docs.thetpa.ai/deai-tokenized-processing-architecture/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.thetpa.ai/deai-tokenized-processing-architecture/architecture.md).

# Architecture and how a request works

DeAI TPA runs in two stages. **Today** a request passes from the user's wallet to a TPA endpoint and on to Stage's platform, with TPA ownership recorded on Ethereum. **From 11 October 2027** the same TPAs move onto TPAI Chain, where every AI job is checked, paid, proven and settled on chain, and the GPU work runs in a datacenter GPU pool built into the protocol. This chapter describes both: what works now, and the design it grows into.

## Today: how a request works

```
User / wallet  →  TPA endpoint (e.g. GPT-010)  →  DeAI TPA platform
                                                     ├─ Path A: frontier models via provider APIs
                                                     └─ Path B: open base models + LoRA, served with S-LoRA
Ethereum: TPA ownership today, TPC payments from launch
```

Ethereum records who owns each TPA today and will carry TPC payments from the ERC-20 launch on 29 March 2027. Requests and model hosting run on Stage's servers; moving compute onto TPAI Chain is the planned path to decentralization.

There are two paths behind a TPA. Frontier models are reached through their providers' APIs. Open and custom models run on Stage's own servers. Both paths work today **\[Working]**.

### Path A: frontier models

GPT, Claude, Grok, Gemini and others. This works like an aggregator such as OpenRouter or Poe, except that the endpoint is an owned TPA and payment is in TPC.

1. Stage buys usage credits in advance from each provider through its public API and pays the provider in US dollars.
2. The user calls the model's TPA (for example GPT-000) and pays in TPC from their wallet.
3. The DeAI TPA platform, not the TPC token, does the conversion: it takes the TPC and spends the matching provider credit.
4. The platform sends the request to the provider with Stage's API access, receives the answer and returns it to the user.

### Path B: open and custom models

Closed models such as GPT-4 and Claude cannot be self-hosted, because their weights are not public. Open models can be.

1. Stage hosts open base models, such as Llama 3.2, on its own servers, currently on AWS.
2. An AI engineer uploads a LoRA adapter (a small fine-tuning layer) into their TPA and activates it.
3. Requests to that TPA run on the shared base model with the engineer's adapter applied.
4. Stage serves adapters with [S-LoRA](https://arxiv.org/abs/2311.03285), published research from UC Berkeley and Stanford (2023), which serves thousands of LoRA adapters on one GPU. S-LoRA serving is running today **\[Working]**.

### Models available today

More than 20 models are reachable through TPAs **\[Working]**. On 31 October 2026, [thetpa.ai](https://thetpa.ai/models) listed these **\[Verified: listed on the website]**:

| Kind                      | Models (TPA address where shown)                                                                                                                                                       |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Base models, open weights | gpt-oss-20B, Kimi K2 Instruct-0905, Qwen3-Next-80B-A3B-Instruct, Qwen3 0.6B, DeepSeek-V3-0324, Llama 3.1 8B, Llama 3.2 3B Instruct, Gemma 3 27B, Mistral 7B Instruct v0.2, GLM-4.5-Air |
| Image and embedding       | FLUX.1 Kontext (image generation and editing), BGE-Base-EN v1.5 (embeddings)                                                                                                           |
| Stage's own models        | Stage Immersive, Stage 3D Generator                                                                                                                                                    |
| Featured models           | Qwen3 (QWN-000), Llama 3.3 (LMA-000), DeepSeek V3 (DEP-000), GPT-5 (GPT-010)                                                                                                           |
| Agents built on TPAs      | CodeCrafter (APP-100), Prospera (PRP-111), Investara (IVM-567), Bankly (BNK-777), FinVault (YGJ-876), DealMate (DFE-111), GymGenie (LEG-000), Tripster (APL-002)                       |

Stage runs the base models on a small GPU fleet on AWS whose size is not disclosed **\[Founder statement]**. Which listed models run on Stage's own GPUs and which are reached through a provider's API is **\[Open]**.

### Where the cost savings come from

There are two sources, one for each path.

* **Custom models (Path B): shared GPUs.** S-LoRA lets one GPU serve thousands of fine-tuned adapters on the same base model. It keeps all adapters in main memory and loads only the ones in use. Against HuggingFace PEFT and vLLM with naive LoRA support, the S-LoRA paper reports up to about 4 times the throughput and several orders of magnitude more adapters served **\[Verified: S-LoRA paper]**. Many custom models can therefore share hardware that would otherwise sit idle, and that sharing is where the savings come from. Stage will publish its own measured cost per request, against a stated baseline, before launch **\[Planned]**.
* **Frontier models (Path A): pay as you go.** Flat subscriptions charge the same whether a customer uses a little or a lot, so light users pay for capacity they never use. Pay-per-use pricing through a TPA charges only for what is used **\[Analysis]**.

All prices are set in US dollars and paid in TPC **\[Founder statement]**.

### Fees and minimum balance before TPAI Chain

Opening a session on a TPA costs a small TPC session fee, similar to a gas fee on a blockchain. **Today, before TPAI Chain**, the TPA owner receives 80% and Stage 20%. The 80% is meant to encourage developers to publish more AI models, and Stage's 20% covers running the gateway, the servers and the provider accounts **\[Founder statement]**. **On TPAI Chain, from mainnet**, Stage takes no protocol fee, and the on-chain split described in [TPCoin](https://docs.thetpa.ai/deai-tokenized-processing-architecture/tpcoin.md) replaces this.

To deploy a model or agent, a TPA must hold TPC, much as a TRON account holds TRX. The minimum is set in US dollars and held in TPC, roughly **$100** for an ordinary deploy such as an agent or a LoRA model; an automatic formula sets it by function. The dollar amount converts to TPC at the market price, so fewer tokens are needed as the TPC price rises. It is checked only when access is granted, so a later fall in the TPC price does not remove access already granted, and it is separate from TPC spent on AI usage **\[Founder statement]**. Which markets set the price, and over what time window, are **\[Open]**. Validator nodes follow their own licensing terms (see [TPAI Chain](https://docs.thetpa.ai/deai-tokenized-processing-architecture/tpai-chain.md)).

## On TPAI Chain: the TPA as gateway to AI power

On TPAI Chain a TPA is an AI endpoint, and it is the only way to reach the GPU pool. The user picks a model or agent by its AI address. The TPA's AI contract converts TPC into AI usage at a US dollar price, routes the job, and settles the split on chain **\[Planned]**.

|                      | GPU pool TPA                                                               | External API TPA                                                |
| -------------------- | -------------------------------------------------------------------------- | --------------------------------------------------------------- |
| Where the model runs | The TPAI Chain GPU pool                                                    | The TPA owner's own API (for example a frontier model provider) |
| Who sets the price   | The TPA owner, above a floor price                                         | The TPA owner                                                   |
| Payment              | Split on chain between owner, GPUs and validators                          | Split on chain between owner and validators                     |
| Proof                | Receipt signed inside an attested GPU, with model and adapter fingerprints | Owner-signed receipt, no attestation, labelled External         |
| Privacy levels       | Standard or Confidential                                                   | External only, never Confidential                               |

Every AI payment is split on chain; the exact shares and the floor price are set out once, in [TPCoin](https://docs.thetpa.ai/deai-tokenized-processing-architecture/tpcoin.md).

**AI contracts live inside a TPA.** TPAI Chain has no smart contracts in the usual sense; it has AI contracts, and everything deploys inside a TPA. An AI contract holds the rules for a model or agent: who can call it, its price, its permissions and where its income goes. The model itself runs on the GPU pool or the outside API and sends back a receipt **\[Planned]**.

**Agents can work together.** An AI contract can call and pay AI contracts in other TPAs: a legal agent can hire a translation agent. Agents can hold and spend TPC within limits the TPA owner sets: a daily spending cap, approved contracts only, and approval keys for anything above the cap **\[Planned]**.

**Trained models stay home.** A model fine-tuned on the GPU pool runs only on TPAI infrastructure. Its weights are encrypted, bound to one TPA, and move only when that TPA is transferred. Enterprises that fine-tune on their own data can export their model under an enterprise contract from launch; everyone else's models stay on TPAI Chain **\[Planned]**.

**External API TPAs are trusted reporting, backed by accountability.** Anyone can connect an outside API to a TPA. Because the model runs on someone else's servers, nobody outside can verify which model answers, so the protection is accountability rather than proof: the owner passes KYC, declares the model, posts a slashable bond and is labelled External. Validators run quality checks and can remove the TPA and slash the bond on evidence of misreporting. External TPAs are never used for Confidential work. Official model makers get a **Verified provider** badge **\[Planned]**.

## How an AI job flows on TPAI Chain

Users pay through a **session balance**, like a prepaid card, so AI calls never wait for a block. The AI work runs off chain; the chain checks the rules when a session opens and settles the calls in batches **\[Planned, preferred design]**.

| Step | Where          | What happens                                                                                                                                                                                                             |
| ---- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 1    | Wallet         | A user or agent funds a session balance on a TPA once, in TPC, from a TPAI21- wallet                                                                                                                                     |
| 2    | TPAI Chain     | The TPA's AI contract checks the rules: permissions, price and balance                                                                                                                                                   |
| 3    | Off chain      | Each call goes straight to the GPU pool, or to the owner's external API, without waiting for the chain. When the GPU pool is busy, the Meta Energy (PING) formula and the fair-share cap set the order among paying jobs |
| 4    | GPU pool / API | The model runs on an attested GPU. The approved serving software records fingerprints of the model, the adapter, the request and the answer, and meters tokens and GPU time                                              |
| 5    | Off chain      | The result goes straight to the user. A signed receipt is kept for settlement                                                                                                                                            |
| 6    | TPAI Chain     | Every few minutes, or when the session closes, the receipts are recorded and the calls are settled together with the payment split. Unused balance returns to the user                                                   |

Only receipts and payments go through the chain. AI output is not identical from run to run, but consensus must be, so the chain never runs the model itself. Consensus therefore never waits for AI work, and blocks can target finality of about 1–2 seconds, confirmed on testnet **\[Analysis]**.

## Pricing and metering

Each model has a US dollar price per compute unit. Users pay in TPC, converted at payment time by a price feed, so TPC price swings never break the payment split **\[Planned]**.

* **GPU cost** comes from a cost table per GPU type that includes expected idle time, updated on a fixed schedule.
* **The serving software meters real GPU time and tokens**, and the signed receipt records them.
* **The TPA owner sets the price** above a floor that guarantees the GPU share covers the real GPU cost (see [TPCoin](https://docs.thetpa.ai/deai-tokenized-processing-architecture/tpcoin.md)). The owner is paid for building the model or agent, not for routing a call.
* **External API TPAs** set their own price; the owner pays their own compute.
* **Ordinary transaction fees** are set by an automatic formula, like Ethereum's gas pricing, from network traffic and the resources a transaction uses; they go 100% to validators. AI usage is priced separately by each TPA owner above the floor. The formula's exact inputs are **\[Open]**.
* **Market pricing** for GPU time is added later, once many datacenters compete.

Before launch, Stage compares the cost per call of the leading models at the floor price with leading AI APIs. If the floor is not competitive, the split for GPU pool TPAs is revisited before launch **\[Founder statement]**.

## Trust: proof of compute, privacy and fake TPAs

Users trust TPAI Chain because work is proven on verifiable hardware, data is protected and fake endpoints are removed by validators **\[Planned]**.

**Proof of compute, in layers.**

1. **Every GPU is attested before it works.** No GPU in the pool can take jobs until NVIDIA attestation proves it is a genuine NVIDIA GPU running approved drivers and approved serving software, and the check is repeated regularly. This applies from day one, so even while Stage runs the only GPUs, trust rests on verifiable hardware proof rather than on Stage's word.
2. **Every receipt says what ran.** Attestation proves the hardware and the approved serving software. That software records a fingerprint (hash) of the exact model and adapter it ran, and of the request and the answer, in a receipt signed with a key held inside the attested environment.
3. **Spot checks from launch.** Super nodes re-run a random sample of jobs from day one, and the sample grows as partner and open datacenters join. Every job records its model version, settings and random seed, so a spot check repeats it in deterministic mode and compares the result; where hardware causes tiny differences, the check compares the model's word-by-word probability scores against a set threshold.
4. Every datacenter posts a **slashable bond**.

**How cheating is caught and punished** **\[Planned, preferred design; exact numbers set after testnet]**.

1. **Random checks.** Super nodes re-run a random sample of jobs. The sample is larger for new or low-reputation providers.
2. **Challenge window.** For a set period after each batch is settled, any user or validator can challenge a job with evidence.
3. **Penalty.** A provider proven to have cheated (a wrong model, a fake receipt or inflated usage) loses part of its bond, refunds the affected users, and repeat offenders are removed from the pool.
4. **Reward.** Whoever proves the cheating receives a share of the slashed bond.
5. **The rule behind it.** Penalties are set so that the expected cost of cheating is always higher than what cheating could earn.

**Privacy, chosen per job.**

| Level        | GPUs                                               | Who can see the data                                                              |
| ------------ | -------------------------------------------------- | --------------------------------------------------------------------------------- |
| Standard     | Any attested GPU in the pool                       | Encrypted in transit and on disk; the datacenter could see it while the GPU works |
| Confidential | Attested NVIDIA GPU in confidential computing mode | Nobody outside the protected GPU, not even the datacenter                         |
| External     | An outside API                                     | The outside provider; never allowed for Confidential work                         |

**Data never goes on chain.** The chain stores only receipts with fingerprints of the job. A TPA owner can set a minimum level, for example Confidential only for a bank.

**Fake TPAs are removed by validators.**

1. Any validator reports a TPA with evidence on chain.
2. Randomly chosen super nodes test it.
3. If confirmed, the TPA is paused at once; the owner's funds are untouched.
4. A 2/3 validator vote deactivates it and slashes the owner's bond.
5. The owner can appeal to the review council.
6. A correct report is rewarded from the slashed bond; a false one earns the reporter a license warning.

The same process covers dApps. Every dApp lives inside a TPA, so a harmful or fake dApp is reported, paused and removed the same way, and its TPA owner's bond is at stake.

## Compute priority (PING)

Shared compute is not split equally. GPU power goes to those who pay for it. When the pool is busy, the Meta Energy (PING) formula sets the order among paying jobs, and a fair-share cap stops any single TPA from using more than a set share of the pool at once, so big users cannot push small ones out **\[Founder statement]**. How PING is earned is described in [TPCoin](https://docs.thetpa.ai/deai-tokenized-processing-architecture/tpcoin.md). How the scheduler applies the formula in practice (queue order, batching, limits), and whether a TPA's PING can decrease, are **\[Open]**.

## Performance and usage figures not yet published

The architecture above runs today in its first form, but Stage has not yet published measured figures for it. These are the main evidence still missing from this paper **\[Open]**:

| Figure                                                                  | What it shows                         |
| ----------------------------------------------------------------------- | ------------------------------------- |
| Requests and tokens served per month                                    | Real usage of the platform            |
| Active wallets and TPAs in use                                          | How many people and agents use it     |
| Models on Stage's GPUs versus provider APIs, and the GPU count and type | What Stage actually hosts             |
| Time to first token and tokens per second through a TPA                 | The cost of the extra layer           |
| Cost per request on Stage's servers, against a stated baseline          | Whether the savings claim holds       |
| LoRA adapters hosted, and adapters per GPU                              | Whether S-LoRA works at Stage's scale |

This paper will add each figure, with the date and method of measurement, as it becomes available.
