Your GPU, on the network.

Serve open GGUF models from your own machine and keep 80% of every job, settled in USDC on Solana. The worker dials out; nobody dials in.

Install a worker Worker guide

Release 0.1.0. x86_64 Linux, with or without an NVIDIA GPU.

A few commands and a public address.

The installer shows the EULA, records the version and hash you accepted, fetches the gateway's bootstrap document, and refuses it if the PeerId doesn't match.

# CPU worker. For GPU, add the gpu compose overlay and --compute-cap.
mkdir -p autarcho-worker && cd autarcho-worker
curl -fsSLO https://autarcho.com/workers/docker-compose.yml
curl -fsSLO https://autarcho.com/workers/install.sh
chmod +x install.sh
./install.sh --wallet <YOUR_SOLANA_ADDRESS>
docker compose up -d
docker compose logs -f node

$ ./install.sh --wallet DWXCxtYLofeG772uMfNC3FRge5cinwFb5tnHmk7sf2bF --accept-eula

Fetching https://api.autarcho.com/bootstrap.json

Wrote .env for https://api.autarcho.com
  gateway peer: 12D3KooWPEc9EMvcNttN1G6CSkNQm4gLKT9LEE5uKBJrCS2Wz4nE
  p2p address:  /dns4/api.autarcho.com/tcp/4001/p2p/12D3KooWPEc9EMvcNttN1G6CSkNQm4gLKT9LEE5uKBJrCS2Wz4nE
  wallet:       DWXCxtYLofeG772uMfNC3FRge5cinwFb5tnHmk7sf2bF
  EULA:         version 1.0, sha256 e1c81bcfa3b550d518c62dfeacebbb19d278347334f6858f6d8a40c91c37ed3a, accepted at 2026-10-22T17:11:15Z
  image:        ghcr.io/czeti/node:0.1.0

Next:
  docker compose pull
  docker compose up -d
  docker compose logs -f node

Data: worker-data holds your worker identity. Back it up; set WORKER_DATA to an
absolute host path in .env if you want a simple bind-mount backup.

Output from a real run against the public gateway, 22 October 2026, copied out of the terminal. The wallet is a throwaway address generated for that run. The PeerId and EULA hash are the live values.

--wallet is a public Solana address, not a key. The compose file refuses to start without it, and the node never needs the private key. Models download into the cache volume on first request.

What the host has to be.

Operating system: x86_64 Linux. ARM is not supported in this release.
Runtime: Docker Engine + Compose v2, plus curl and jq for the installer.
Memory and disk: At least 16 GB RAM and 20+ GB free free for the GGUF model cache. Larger models need more of both.
Network: Outbound TCP 443 and 4001 only. No inbound ports, no public IP, no DNS.
GPU: Optional. CPU workers are fully supported. The validated GPU path is CUDA 75 (Turing — GTX 16xx, RTX 20xx). CUDA 80, 86, 89 and 90 images are not published in 0.1.0.
Release: Pin TAG=0.1.0. Never run latest.

Payouts.

The gateway verifies receipts for completed work. The payout service batches verified receipts and settles them to your wallet on Solana mainnet. There is no fixed schedule: a batch goes out when there is verified work and the amount is worth a transfer.

The operator keeps 80% of each job and the protocol keeps 20%. Your first payout also creates your USDC token account, which costs rent, so a wallet needs at least 2 USDC before it can be paid. Anything below that is carried into the next batch rather than lost.

Electricity, hardware, and your own tax situation are yours. Autarcho does not guarantee earnings, and there is no per-day figure on this page because nobody can know it before the work arrives.

Why the payout address is the whole wallet surface.

The software is proprietary. That is a real objection, so here is what is true instead of a claim that it is open.

Payout address only. The worker never asks for a private key or a seed phrase. The installer validates a public address and writes it to the config; that is the whole wallet surface.
Outbound only. No inbound ports, no port forwarding, no public IP, no DNS record. The container publishes nothing by design.
Pinned gateway. The installer checks the gateway's PeerId and refuses a bootstrap response for a different peer. The current one is 12D3KooWPEc9EMvcNttN1G6CSkNQm4gLKT9LEE5uKBJrCS2Wz4nE.
EULA on record. The accepted version, document hash, and timestamp are written at install, so the terms you agreed to are auditable later.
No self-update. The node never patches itself. You update with docker compose pull, on your schedule, to a pinned tag.
Verifiable money. Payouts are USDC transfers on Solana. The ledger is the chain, not a dashboard screenshot.

What 0.1.0 does not do.

GPU matrix: Only CUDA 75 (Turing, GTX 16xx and RTX 20xx) is published. Ampere 80/86, Ada 89, and Hopper 90 tags are not available yet; use the CPU stack if your card has no image.
Architecture: ARM hosts are not supported. x86_64 only.
Models: GGUF, registered on the gateway. The node pulls a model into its cache the first time a job needs it, and what your hardware can hold decides what you can serve. Models vary in size and context window, so a larger host can serve a larger model.
Source: Proprietary. No source distribution in this release. The contract and the payouts are verifiable; the code is not.

Before you install.

Do I need to open any ports?

No. The worker dials out to the gateway on TCP 443 and 4001. Do not add port mappings; the compose file publishes none by design.

Can the worker touch my wallet?

It only receives a public address. The worker never asks for a private key or a seed phrase, and the payout service sends USDC to the address rather than withdrawing from it.

How often do I get paid?

Verified work is batched and settled on-chain; there is no fixed schedule. The first payout to a new wallet needs at least 2 USDC to create its USDC token account. Below that, earnings carry forward.

What happens if I lose the data volume?

You get a new PeerId and appear as a new worker. Back up the worker data volume, or bind-mount it to a host path so it can be archived. Keep that backup private, because it contains the worker identity.

What do I actually earn?

It depends on how much work is routed to you and which models you serve. There is no per-day figure to quote and we will not invent one. If a fixed income is what you need, this is not that.

Put the idle hours to work.

Download install.sh Worker guide