Developers deploy Python functions to Animica and customers pay ANM per execution. Your machine claims those jobs, runs them in the same hardened Docker sandbox contract the gateway itself uses, and earns 10% of every execution's price — credited as real, spendable ledger balance the moment your result settles. Not an IOU.
Live from the dispatch queue and the settlement ledger.
The provider network is open and the queue is real, but nobody is serving it right now — jobs currently run on Animica's own gateway sandbox. Be the first machine on the fleet: the setup below takes about five minutes, and early providers face zero competition for every fleet-eligible job.
The split is policy-driven and enforced in one settlement transaction.
A customer pays a metered price per execution (base + CPU-ms + memory + egress). When your machine ran it, 10% of that price is yours — the current network policy's provider share, applied by the same exactly-once settlement that debits the customer and credits the developer. The parts always sum exactly to the price.
Your payout posts to the append-only ledger as a SALE_CREDIT in the same database transaction that completes the job — real balance you can spend or withdraw, not a deferred IOU. Only revenue-bearing executions are dispatched to the fleet, so a completed job is always a paid job.
If the developer's code raises or times out, the caller still pays the metered resource cost — and you still receive the provider share of it: you faithfully burned real compute. Only work you never deliver (crash, lease expiry) pays nothing, and the job is requeued for another provider.
Jobs are untrusted Python. The worker runs each one in the same contract the gateway uses: --network none, read-only rootfs, all capabilities dropped, memory/CPU/pid caps, unprivileged user. The worker checks for Docker and the anm-pycloud-runtime:1 image at startup and refuses to run without them — there is no unsandboxed fallback, by design.
Linux (x86_64 or arm64) with Docker, Python 3.9+ for the worker itself, 2+ CPU cores and 2 GB+ free RAM (each job is capped at 1 GB and one CPU). A GPU is optional — advertise it and you'll be eligible for GPU job kinds as they ship. Stable outbound HTTPS to animica.dev; no inbound ports, no port forwarding.
Earnings land in the marketplace ledger account for the bech32m anim1… address you register with. Create one in the Animica wallet if you don't have one — key material never touches the worker; the address is purely where money goes.
The worker self-registers with a locally generated bearer token (the server stores only its hash), builds the exact sandbox image the gateway runs, then claims jobs in a loop.
pip install -U animica python -m animica.cloud_worker build-image --gateway https://animica.dev python -m animica.cloud_worker run --gateway https://animica.dev --address anim1YOUR_PAYOUT_ADDRESS
build-image fetches the sandbox build context (Dockerfile + runner) from /api/cloud/v1/providers/runtime, verifies the sha3-256 digests, and runs docker build locally — you can read every line before you build. Add --name to label your machine, --gpu "RTX 4090" to advertise a GPU, and --once to serve a single job as a test. The token persists in ~/.animica/cloud-worker.json.
Your worker polls /providers/claim; the queue hands out each job exactly once (row-locked claim), with a 5-minute lease your heartbeats extend. You post the result, the execution settles, your share is credited — all in the same request.
Only capability-free, secret-free functions are fleet-eligible. Developer secrets, wallet operations, AI calls and chain access are brokered by the gateway and never leave it — your machine sees the function source, the request payload, and nothing else. Executions are anchored on-chain at deploy time (source hash + artifact hash + DA blob id inside a signed DEPLOY tx) and executed off-chain in this hardened container.
Registration is open — no forms, no approval queue. Completed jobs raise your reputation; failures lower it, and a provider that keeps failing is automatically suspended from claiming. Priority customers' jobs sit higher in the queue; the per-developer admission cap keeps any one developer from monopolizing the fleet.