Kracht documentation

Kracht is a two-sided marketplace for GPU compute. Renters launch a GPU and pay per second while it runs; providers list idle hardware and keep 85% of what it earns. Both sides talk to one control plane over a REST API under /v1, from the console, the CLI or raw HTTP. What follows is what the platform does today, section by section, with the parts that are not finished named as such.

Proven

Launch, meter and settle on real hardware; a renter SSH login to a GPU rental with one card scoped in; snapshot and restore; the provider bootstrap on an untended Ubuntu box. exercised against the live stack

Not yet

Payments run against a mock provider, so no real money has moved. Studio and Autopilot are planned surfaces on the same meter, and their pages will be written when there is behaviour to document. payments off studio, autopilot

Where it runs

The site on kracht.ai; the control plane at cp.kracht.ai, in Frankfurt; one Postgres database behind both.

• The Compute product→
• How it works→
• Status→

Six steps from nothing to a shell on a GPU, and one to stop paying. The console at /app/launch and the CLI drive the same API, so either works at every step.

1. 01

   Sign up

   Create an account at /sign-up. Sign-up creates the account, the profile and the owner membership in one go. You can look around before adding any credit.
2. 02

   Create an API key

   At /app/settings/keys. Keys are stored only as a hash and are never echoed back, so copy it when it is shown.
3. 03

   Sign the CLI in

   kracht login, then paste the key. kracht whoami confirms who you are and shows your balance.
4. 04

   Launch

   kracht launch --gpu 1 --ssh rents a machine and opens a shell once it is ready. Two keys are involved, not one: your SSH key is the login and your WireGuard key is the route in, because providers sit behind NAT. Both keypairs are generated on your machine and only the public halves are sent. A launch missing either is refused.
5. 05

   Connect

   kracht ssh <instance> for a shell, or kracht connect <instance> for the details. Inside you are root on Ubuntu 24.04 with a read-only root filesystem; /workspace is your writable scratch.
6. 06

   Stop

   kracht stop <instance>, or DELETE /v1/instances/:id. The meter stops with it. Stop with a snapshot from the console to keep /workspace for a later rental; otherwise it is wiped.

kracht login
kracht launch --gpu 1 --ssh
kracht ls
kracht stop <instance>

kracht login
kracht whoami

kracht launch --gpu 1 --ssh

kracht stop <instance>

• For users→
• Pricing→
• Launch from the console→

Lending a machine is one command on a fresh Ubuntu box. The agent runs as an unprivileged system user, isolates each rental in its own container and session network, and reports capacity so the marketplace can match it. Register first: the installer needs a token that only registration issues.

1. 01

   Register the machine

   Add a host at /app/machines, or POST /v1/me/hosts. You get an agent token, shown once, bound to that machine from the moment it exists.
2. 02

   Run the installer

   One line, as root, on Ubuntu. Idempotent: re-running it upgrades the agent. It installs Docker, creates the kracht-agent user, installs the systemd unit, sets up the isolated session network and builds the rentable instance image on your box.
3. 03

   Set your price

   PUT /v1/me/hosts/:id/listing, or the controls on the host in the console. Changing the price never touches a rental already running: the rate was frozen onto it at match time.
4. 04

   It appears in your fleet

   The agent registers itself and heartbeats every 15 seconds. sudo systemctl status kracht-node-agent on the box says whether it is up; GET /v1/me/hosts says whether Kracht can see it.

curl -fsSL https://cp.kracht.ai/install.sh | sudo bash -s -- \
  --control-plane-url https://cp.kracht.ai \
  --enrollment-token <YOUR_TOKEN>

Install dir

/opt/kracht-node-agent

State

/var/lib/kracht-node-agent

Config

/etc/kracht-node-agent

Service

kracht-node-agent

WireGuard port

51820/udp

Instance image

kracht/instance-base:latest, built on your box by the installer

• For providers→
• Your machines→
• Security→

One binary, eight commands. kracht launch starts billing per second and kracht stop ends it; kracht ls is the honest answer to whether you are still being charged. Homebrew on macOS, or one shell line on macOS and Linux; Windows builds are downloadable from the install page.

brew trust kracht-ai/tap
brew tap Kracht-AI/tap
brew install --cask kracht

A Python SDK is planned and not published. Until it is, the REST API below is the programmatic surface.

• Install the CLI→
• API keys→

Every endpoint sits under /v1 and takes a bearer key. kracht.ai/v1/* forwards to the control plane; the CLI talks to cp.kracht.ai directly. Money is returned as strings in EUR so nothing is rounded in transit, and the account is always derived from your credential, never from a parameter.

curl -H "Authorization: Bearer $KRACHT_API_KEY" https://kracht.ai/v1/me
curl https://kracht.ai/v1/gpus        # 401 without a token: the healthy answer

Auth

Authorization: Bearer <api key>. Keys come from /app/settings/keys. The agent protocol uses the host's agent token in the same header.

Envelope

Success is { "data": ... }; failure is { "error": { "code", "message" } }, with the codes in the table below.

Limits

Per route, per caller IP, per minute, at the edge. The control plane has no limit of its own. Over the limit answers 429 with Retry-After.

Ownership

An id that is not yours answers 404, not 403, so the id space cannot be enumerated.

Health

GET https://cp.kracht.ai/healthz answers 200 when the control plane is up.

• Status→
• API keys→

Everything is metered per second, in euro, from usage events, and drawn against a prepaid balance. The rules below are the ones the ledger enforces, not a pricing page: the prices themselves are on /pricing, and your own charges at /app/billing.

Unit

Per second, in euro, from usage events, while the instance is running. No hourly minimum and no egress charge.

Precision

Amounts are numeric(16,6) in the database and travel as strings, so nothing is rounded in transit. Settlement is exact to the microeuro.

Split

The take rate is 15%. A provider keeps 85% of what a card earns, and the split is exact-integer so no cent leaks in the rounding.

Price

The matched rate is frozen onto the rental at match time. Billing uses it, never the live listing, so a provider re-pricing cannot change a running rental.

Balance

A sum over an append-only ledger, never a column. Deposits, holds, charges, earnings and payouts are all entries.

Retries

Usage is unique on (instance, seq) and every ledger entry carries an idempotency key, so a retried heartbeat cannot bill twice.

Holds

Credit is held before compute runs and released in full when the rental ends. A session that fails at startup takes a hold, releases it, and produces no charge.

Ending

Terminal states are one-way. A late heartbeat describing an already-settled rental cannot reopen it and start billing again.

Snapshots

An archived workspace is charged per GB-month while it is ready. The rate comes from GET /v1/me/storage, and deleting the snapshot stops the charge.

Withdrawals

Only earned money leaves to a bank account. Topped-up credit is spendable on compute and is not withdrawable. What is payable is the lower of earnings less payouts and the account's actual balance.

Payments

Not switched on yet. The payment provider is a mock, so every balance today is credit granted by hand and no real money has moved. The ledger arithmetic is proven; the payment rail is not.

• Pricing→
• Your billing→
• Ledger→

A rental is single-tenant for its whole life: no time-slicing, no partition shared with a stranger, and the machine's owner gets no shell into it. The container and its scratch are destroyed at teardown. The table is what was verified on the test provider box; the security page covers encryption, disclosure and what is not covered yet.

Base image

Ubuntu 24.04 with OpenSSH, python3 and venv, git, curl, vim and htop. Key-only sshd, no passwords, no X11 forwarding. Your public key is injected at start; host keys persist for the life of the rental.

Encrypted

TLS on every call, encrypted at rest by the database provider, and every credential stored only as a hash.

Auditable

Every euro and every state change lands in an append-only ledger, exact to six decimals.

• Security→
• Privacy→

What the platform observes about itself today, what it does not, and the limits a renter meets first. There is no uptime figure anywhere on this site because nothing measures one; the status page says the same in the same type size.

• Status→
• Changelog→

Questions the site already answers, each on the page that answers it. The help centre has a search box over every one of them.

• Which parts of Kracht actually work today?→
• Is any real money moving yet?→
• Do I need a credit card to start?→
• What do I need before I can connect?→
• Can I bring my own Docker image?→
• Can I snapshot a rental and come back to it?→
• How do I stop paying?→
• Is there an uptime SLA?→
• How exactly am I billed?→
• Can a provider raise the price while I am running?→
• What does a provider earn?→
• Whose hardware am I running on?→

• Help centre→
• Contact→