Managed graphics processing units for training, fine-tuning and inference. Describe the job; Joul matches it to the right hardware and keeps it running to the finish. At a fraction of big-cloud rates.
Tell us what you run — we will come back with a price.
You have lost a three-day run to a node that vanished at 2am. You have opened a cloud invoice that made you rethink the roadmap.That is why we built Joul.
Your job runs on a pooled fleet we operate ourselves — not a single machine on somebody's shelf. You will not get a hyperscaler's enterprise service agreement from us, and you will not pay for one either.
Your work is placed on machines that suit it and watched until it is done. Read its output while it runs, stop it when you choose, and find nothing stale left behind.
Your account carries an agreed ceiling: how many cards of which model, and for how long. Work inside it runs. Work beyond it is refused with a plain sentence — never queued for ever, never billed as a surprise three weeks later.
No cluster wrangling, no driver roulette. Describe the job; get a running machine.
Hyperscalers are reliable and on demand, and you pay for it. Neoclouds are reliable and affordable, and they want a long-term commitment. Marketplaces are affordable and on demand, and a node can vanish under your run. Joul is the fourth combination: turnkey, on demand, reliable and affordable, in one machine.
One short document — which container image, what command, how many cards of which model. The platform finds the machines, runs the work and tells you how it went.
Write a few lines: your image, your command, the card you want and how many. Cores and memory come with the cards, so you never calculate them.
One command sends the document. If your allowance covers it, it is accepted on the spot; if the fleet is busy, it waits its turn and starts when capacity frees.
A job with several steps passes files from one step to the next on its own. A service that must stay up — a model answering requests — gets a name you choose and, when the model needs more than one machine, is split across them.
List everything you have running. Drill into one job part by part. Read the live output, including from a part that died and restarted. Stop anything, and everything belonging to it goes with it.
$ cat finetune.yaml name: finetune-support type: workflow steps: - name: train image: registry.example.com/team/trainer:1.4 command: [python, train.py, --epochs, "3"] gpus: 4 gpu_type: H100 # cores and memory come with the cards▍
$ joulctl submit -f finetune.yaml accepted finetune-support 4 × H100 within your allowance placed on the fleet · waiting for a gang of 4 cards running finetune-support/train started 00:00:07▍
$ cat serve.yaml name: assistant type: deployment steps: - image: registry.example.com/team/server:2.0 command: [vllm, serve, /models/qwen-14b] gpus: 2 gpu_type: H100 port: 8000 readiness: /health $ joulctl submit -f serve.yaml accepted assistant · reachable as assistant once ready▍
$ joulctl list NAME TYPE STATUS AGE finetune-support workflow running 41m assistant deployment ready 12m $ joulctl logs finetune-support epoch 2/3 step 1840 loss 0.412 epoch 2/3 step 1850 loss 0.409 $ joulctl stop finetune-support stopped finetune-support · pods, service and gang removed▍
One job, from a sentence to a running machine.
Marketplaces hand you parts. Joul hands you a finished machine.
An hour on a card is not an hour of useful work. Failed runs, retries, idle gaps and mismatched hardware eat a share of every invoice — and you pay for all of it, useful or not.
There is a name for the share that counts: goodput. Joul is built around it. Every job is placed on hardware that suits it — the card you named, whole machines when you ask for them — and kept doing real work, so more of what you pay for comes back as finished runs.
The share of paid compute that becomes finished work. Everything we build pushes it toward one.
If you burn card-hours, Joul pays off.
Bring the container you already build. Nothing to rewrite.
Say which model your work needs and it runs only on machines that carry it. Cores and memory come with the cards.
Work that finishes and work that stays up, written the same way and reached under a name you choose.
Work that must not share a machine asks for exclusive use and gets it.
You move your own data in and out. We never fetch your inputs, never deliver your outputs, and hold none of your credentials. Your work cannot be reached by another customer's, and theirs cannot reach yours.
A password, a Google account or a GitHub account. Every request is checked at the moment it is made, so a revoked access takes effect on the very next call.
One public endpoint, one published interface, one command-line client. Your account manager can walk you through your first submission in a few minutes.
A short document: the container image, the command, the card model and how many. A multi-step pipeline adds a step per line. That is the whole format.
One command-line client. It signs you in, submits your document, lists your runs, reads their output and stops them.
Your work waits its turn and starts when capacity frees. A busy moment is never a refusal.
The submission is refused with a sentence saying why — which model, how many cards, or that the allowance has lapsed. Nothing is silently queued.
Yes. Write it the same way as a job, give it a name and a port, and reach it under that name for as long as you keep it running.
Nobody on our side. You bring the image and move the data; the platform runs the steps, holds the files passed between them and keeps the result for a retention window. It fetches nothing of yours and holds none of your credentials.
More reliable than a marketplace node; a step below a hyperscaler's enterprise service agreement. For most training, fine-tuning and inference work, that is the right trade.
The share of paid compute that becomes finished work — productive compute divided by total compute. It is the number we optimise.
Model, scale, timeline — whatever you have. Our team will come back with a price and a plan to get you running.