Architecture#
TOG keeps three things apart that most compute networks merge into one chain: consensus, application logic and the machines that do the work. Each layer has one job.
| Layer | What it is | What it does | What it never does |
|---|---|---|---|
| TOG Hub | The Layer 0 chain, run by validators | Orders and finalizes every connected chain, holds accounts and bonds, keeps the registry of machines and runs the compute and storage market | Run a container |
| AppChains | Application chains built with the TOG SDK | Hold application logic: who may order jobs, how results are priced, what a job means for the app | Choose their own finality: the Hub validates every block |
| The Grid | Bonded compute and storage workers | Run jobs in sandboxes, hold job data, check each other's results | Take part in consensus |
The TOG Hub#
The Hub is a single proof-of-stake chain with fast, final blocks: a block is final as soon as it is in the chain, with no waiting for confirmations. Its target block time is 2 seconds.
Clients never have to trust a single server. Workers, tog-cli and the other tools follow the Hub with a light client that checks each block's signatures and reads state with proofs.
Time on the Hub is counted in blocks, sessions and eras:
| Unit | Length | What changes |
|---|---|---|
| Block | 2 s target | Transactions are ordered and final |
| Session | 300 blocks on the testnet | Duties of validators and workers rotate |
| Era | 1 800 blocks on the testnet | The validator set can change |
AppChains#
An AppChain is a deterministic Wasm runtime registered on the Hub. Its collators gather transactions and build blocks, and Hub validators check every block before it becomes final. A new chain therefore does not need to recruit validators of its own, and AppChains exchange messages with each other and with the Hub without bridges.
An AppChain decides its own application rules: its fees, which machines may run its jobs (for example a minimum isolation level, GPUs or regions), and what counts as "the same result" for its kind of work. Finality, bonds and the compute market stay on the Hub.
See Build an AppChain.
The Grid#
The Grid is made of machines whose owners have locked a bond on the Hub.
- Compute workers run container jobs (OCI images) on CPUs and, later, GPUs. A worker does not pick its jobs: the Hub assigns them.
- Storage workers hold job images, inputs, checkpoints and outputs, and regularly prove they still hold them.
A job is never on the path of block production. Blocks carry only its milestones, so a job can run for hours or days while blocks keep coming.
How a job runs#
- Submit. A user or an AppChain sends a job: a container image, its inputs and a budget, which the Hub holds in escrow.
- Assign. The Hub assigns the job to an eligible bonded worker.
- Run. The worker runs the container in a sandbox. Long jobs run in segments with checkpoints, so another worker can resume one if the first goes away.
- Check. Other workers independently re-check the result. A worker whose result is wrong loses part of its bond.
- Settle. Workers are paid from escrow for checked work, the unused budget is refunded, and the output is available to the sender.
The steps from the user's side are in Run a job.
Inside a worker node#
A compute worker is three processes with separate privileges:
| Process | Binary | Does |
|---|---|---|
| togd | tog-worker |
All network traffic: the Hub light client, peer-to-peer, job scheduling |
| signer | tog-signer |
Holds the worker's keys and signs for togd. togd can ask it to sign but cannot read a key |
| executor | tog-executor |
Runs jobs in their sandbox. It opens no network socket and talks only to togd |
Isolation comes in tiers. The first public testnet runs CPU jobs with the plain process runtime (tier T1, no container sandbox), so workers should run on a dedicated machine or VM. Stronger sandboxes (gVisor, microVMs) and GPUs come in later testnet releases.
Roles#
| Role | Locks a bond | Hardware | Does |
|---|---|---|---|
| Validator | Yes | Server with high uptime | Produces and finalizes Hub blocks, checks AppChain blocks |
| Collator | Small bond per AppChain | Modest | Builds blocks for one AppChain |
| Compute worker | Yes | Linux machine, CPU (GPU later) | Runs and re-checks jobs |
| Storage worker | Yes, per stored slot | Disk and bandwidth | Holds job data and answers storage checks |
One operator may run several roles, but the network never assumes that they do.
What is not in the testnet yet#
- GPU jobs and sandboxed isolation tiers (planned for later testnet releases).
- Confidential jobs in attested enclaves (after mainnet).
- Bridges to other chains and on-chain governance (after mainnet).