# Hinode > A cloud GPU computer: a Linux desktop with a GPU, rented by the minute, with its screen streamed to the computer you already own. You keep a workspace, add bigger machines beside it while the work needs them, and pay for what runs. Prices in these documents are the ones Hinode charges: each page is rendered from the same rate table as an invoice, when it is read. Rates change, so read the page rather than remembering a figure. This is the whole of the documentation. The same pages are served individually, and listed, at https://hinode.run/llms.txt --- # What Hinode is Source: https://hinode.run/docs/what-hinode-is Hinode rents you a Linux computer with a graphics card in it, and puts its screen on the device you already own. It is a real desktop, not a notebook interface and not a queue you submit work to. You sign in, connect, and a full Ubuntu desktop appears in a window on your Mac, PC or Linux computer. What you do there is what you would do on a workstation under your desk: install applications, open files, drag things around, watch a render finish. The machine keeps its disk between sessions, so what you installed yesterday is still installed tomorrow. It is built for work that needs a GPU and has a window: image and video generation, model training and fine-tuning, 3D — anything where you watch the result rather than read a log. If your work never needs a screen, Hinode still suits you — you can reach the same machine over SSH and never open the desktop at all — but the screen is what most people come for. ## What you get **A workspace** you keep. It has a name and an address, and a computer with a desktop and a small slice of a graphics card: it holds your home folder, your files and the programs every machine starts from. It bills while it runs and pauses itself when nobody is using it. It is where your things live, not where the heavy work runs. **Machines you add beside it** when you want a whole graphics card, for as long as the work lasts. You choose how much graphics memory and how much system memory each one has. A machine bills while it runs, pauses itself when nobody is using it, and is gone when you delete it. **One place for big files.** Models and datasets live where every machine in the workspace can see them, so a machine you add tomorrow already has them. ## What it is not It is not a shared computer. The graphics card in your machine is yours while the machine is running — nothing else is scheduled onto it. It is not a subscription with an allowance. You are billed for what you run: the workspace at $0.297 an hour and each machine at its own rate, for the time each is running. It is not a place to be careful about clicking. The expensive thing is a machine that is running, and the workspace and machines pause themselves when nobody is working on them. ## Where the machine is Hinode runs in two places: the United States (`us-east-1`) and Europe (`eu-central-1`). A new workspace is created in whichever answers your computer faster, and it stays there — the machines you attach and everything you store are in the same place. The distance costs you at the screen, not at the work. A render takes the same time either way; a desktop on the other side of an ocean answers your mouse a little later. ## The desktop needs a desktop The screen of the workspace or of a machine is streamed to your own computer: to the Hinode application on macOS, Windows or Linux, or to a tab in Chrome or Edge. Safari, Firefox and phones cannot show it. Everything else about your workspace works from anywhere, including from a phone: you can see what is running, what it costs, and turn things off. --- # Your first hour Source: https://hinode.run/docs/getting-started From signing up to a render on a whole graphics card, in five steps. Most of the hour is downloads, and you can work while they run. ## Create a workspace Sign up at hinode.run and name your workspace. The first workspace starts once you add credit, from $10.00, and your first top-up gets $5.00 extra. When the credit runs out, add more from $10.00; every minute is paid from it. The workspace costs $0.297 an hour while it runs. It starts in a couple of minutes, in whichever region answers your computer faster — the United States or Europe — and stays there. ## Connect to it Install the Hinode application on your Mac, Windows PC or Linux computer and sign in, or stay in Chrome or Edge on a computer. Press Connect on the workspace, and its Ubuntu desktop opens in a window. Signing in to the application also sets up SSH, so `ssh` followed by your workspace's name works from a terminal straight away. ## Install what you need On the workspace screen, pick applications from the catalog — ComfyUI, JupyterLab, Ollama and the rest — and press Install. Each card says how much it downloads before you commit. What an application depends on comes with it: ComfyUI brings PyTorch. Anything outside the catalog installs the usual way, with `apt`, `pip` or `conda`, in a terminal on the workspace. ## Save a snapshot When the workspace has what you want, save it. The snapshot is what every machine you attach starts from, so anything installed after the last save is on the workspace and not on the next machine. Add a line saying what changed, and the list of versions reads as a history. ## Attach a machine and work Attach a machine, and pick how much graphics memory and system memory it has: machines run from $1.75 to $12.58 an hour. It starts from your newest snapshot, with your applications already on it. Connect to it, or open ComfyUI from its Connect menu in your own browser. Put models and datasets in the shared folder, where every machine can read them. When you walk away, the machine pauses itself after 15 minutes with nothing running, and a paused machine costs only what is on its disk. --- # A workspace, its machines, and jobs Source: https://hinode.run/docs/workspace-and-machines Three things, and everything else in Hinode is one of them. ## The workspace Your workspace is the place you come back to. It has a name you chose, an address that does not change, and a computer of its own with a desktop and a small slice of a graphics card, at $0.297 an hour while it runs. That computer holds what you keep: your home folder, which the Hinode application also puts in the file manager on a Mac or a Windows PC; the shared folder every machine sees; and the programs you install for your machines to start from. Its desktop streams like a machine's, and you reach it over SSH. Work that needs a whole graphics card runs on a machine. You can pause the workspace and resume it, and it pauses itself when nobody is using it, like a machine. A pause deletes nothing. Hinode also stops it when the credit runs out, and it starts again by itself once credit is added. An account can hold more than one workspace. People use a second one to keep a client's work separate, or to keep an experiment away from something that has to keep working. ## Machines When the work needs a whole graphics card, you **attach a machine**. You pick two things: how much graphics memory it has, and how much system memory. Every combination has its own price per hour: | Graphics memory | 32 GB | 64 GB | 128 GB | 256 GB | | --- | --- | --- | --- | --- | | **24 GB** | $1.75 | $2.36 | $2.73 | $5.99 | | **48 GB** | $3.30 | $3.96 | $5.30 | $7.97 | | **96 GB** | — | $8.05 | $9.56 | $12.58 | The columns are system memory. Each price is the whole cost of an hour with that machine running; the workspace bills beside it, on its own line. A machine is a computer, not a command. It has its own name and its own address and a desktop you can stream; you can open a terminal on it, install things on it, leave something running on it overnight. It starts with the same programs and settings your workspace has, so it is not a bare Linux box you have to set up again. Machines have three states worth knowing: - **Running** — it is on, and it is billing. - **Paused** — you stopped it, or it paused itself. What is installed on it is kept, it costs what is on its disk and nothing else ($0.15 per GB a month), and resuming takes a couple of minutes. - **Deleted** — it is gone, and so is what was on its own disk. Anything in the shared folder is untouched, because that is not on the machine. You can pause a machine yourself, and one that nobody is using pauses itself. ## Jobs A job is one command, run on a machine, with an outcome you can look at afterwards: what it printed, what it exited with, how long it took. It is how you hand work to a machine and stop watching it: a training run, a long batch, anything you would otherwise sit over an SSH session for. You can ask for the machine and the job in one step; the machine stays yours afterwards, takes the next job without being rebuilt, and pauses itself when the work is done. What a job printed stays readable after the machine has paused itself, and after you delete it: the machine sends the end of the log as it goes and again when the job finishes. The whole log is on the machine while the machine is there. You are emailed when a job that ran for more than a couple of minutes ends, and jobs that end around the same time arrive as one message. You can change that to every job, only the failures, or nothing at all. ## How the three fit together The workspace is what you keep: your files, your environment, a desktop, and an address that does not change. Machines are what you add when the work needs a whole graphics card. Jobs are how you hand a command to a machine without standing over it. The workspace and each machine bill for the hours they run. --- # Where your files live Source: https://hinode.run/docs/storage Three places, and the difference between them is what survives what. ## Your home folder Where you land when you open a terminal or a machine's desktop: documents, projects, code, configuration, the things a program writes without being told where. The workspace has one, and so does each machine you attach. Neither has a size to choose. It grows when it fills, and what is on it is what you pay for, at $0.15 per GB a month — nothing to provision, nothing to resize, nothing to guess before you have used anything. Delete a few gigabytes and the bill follows the next hour. You can check what you are paying for with `df -h ~` on the workspace or the machine: the `Used` column is the figure, and it is the same one the invoice reads. The workspace's home folder is also the one the Hinode application puts in the file manager on a Mac or a Windows PC, so you can drag files in and out without opening a terminal. It is there while the workspace is running. Keeping the home folder local is deliberate: a home folder shared over a network makes every program that touches many small files crawl, and the programs you use touch thousands of them — a Python environment, a git repository, an editor's index. Local is what makes them behave like they do on a laptop. Both survive a pause. A machine's home folder goes when the machine goes; the workspace's goes only when the workspace does. ## The shared folder One folder for the whole workspace, and the workspace and every machine in it see the same one. This is where models, datasets and finished output belong. It has no size to choose either. You write to it, and what is in it is what you pay for, at $0.10 per GB a month. A machine you attach tomorrow already has your models, because they were never on a machine in the first place. It reads large files quickly, and reads them from several machines at once. It is a poor place to build a Python environment or check out a repository — put those in your home folder, and keep the big, finished things here. Models you download from Hugging Face land here without you doing anything: `HF_HOME` points at `~/shared/.cache/huggingface` on the workspace and on every machine. So a model is downloaded once for the whole workspace and billed at the shared folder's $0.10 per GB a month. To keep a model on one machine instead, set `HF_HOME` yourself; yours wins. The shared folder is not on any machine, so deleting a machine does not touch it. ## What is installed When you attach a machine, it starts from a snapshot of your workspace: the programs you installed there and the settings you changed. So a new machine is your machine, not a blank one. That snapshot is taken when you ask for it, from the workspace, and you can keep several. A machine that is already running is not changed underneath you — it keeps the version it started with, and picks up a newer one the next time it starts. ## Which region your files are in All three are in the region your workspace was created in: the United States (`us-east-1`) or Europe (`eu-central-1`), whichever answered your computer faster at the time. A workspace does not move between regions, so that is where your files stay. ## What survives what | | Pause the workspace or a machine | Delete the machine | Delete the workspace | | --- | --- | --- | --- | | Home folder on the workspace | kept | kept | gone | | Home folder on a machine | kept | gone | gone | | The shared folder | kept | kept | gone | | What you installed on the workspace | kept | kept | gone | Deleting a workspace ends everything in it, including the address it answered at, and the address does not come back. That is why deleting one asks you to type its name. --- # Snapshots of your workspace Source: https://hinode.run/docs/snapshots A snapshot is what is installed on your workspace, saved as a numbered version. Every machine you attach starts from one, so you set things up once and never again. ## What a snapshot holds The programs you installed on the workspace, the applications from the catalog, and your settings. Not the shared folder: that is one folder every machine already sees, so models and datasets never need to be in a snapshot. A machine gets its own copy of the snapshot on its own disk, so it behaves like a computer you set up by hand. ## Saving one Press Save on the workspace screen, run `hinode env promote` on your computer, or ask your assistant. The workspace stops writing to disk for a second or two, then you keep working while the copy finishes in the background. New machines use the version once it is complete. Give it a line saying what changed — "torch 2.5 and the new LoRA nodes". You can add or change that line later, from the workspace screen or with `hinode env describe`. The workspace screen and `hinode apps` both show what you installed after the last save, so nothing is left out by accident. ## Which one a machine gets A new machine starts from the newest complete version. The attach dialog shows which one that is, and lets you pick an older one instead — the way to check whether something broke with the last change. A machine that is already running is never changed underneath you. It keeps the version it started with, and the machine card says when a newer one exists. To move a machine to the newer version, attach a fresh one. Anything you install on a machine stays on that machine and goes when it is deleted. If it is worth keeping, install it on the workspace and save again. ## How many are kept The five newest versions are kept. Saving a sixth removes the oldest, along with its note. Version numbers keep counting and are never reused, so a number always means the same snapshot. Snapshots are not billed on their own line. What you pay for is the workspace's disk and each machine's, at $0.15 per GB a month for what is written on them. --- # What is on the machine, and how to add to it Source: https://hinode.run/docs/applications A new machine is a complete Ubuntu desktop with a working graphics card: the driver, the desktop itself, a terminal, a file manager, and everything the card needs to be used by anything you install. A new workspace is the same, on a small slice of a card, and it is where you install what your machines should start with. Nobody has chosen a toolchain for you. The applications are yours to pick. ## Installing things Two ways, and both are ordinary. **The applications list.** Hinode keeps a catalog of the things people usually want — ComfyUI, JupyterLab, PyTorch, Ollama, vLLM, LangChain, the AI Toolkit, Axolotl, Chrome, VS Code — and installs any of them for you. It is a window on the desktop, and the `hinode-apps` command over SSH, on the workspace or a machine. One action, and it handles the parts that usually go wrong: a build that runs on the graphics cards machines carry, the environment around it, a way to start it. Some of them are large. Anything that brings PyTorch with it pulls gigabytes and takes a while, so each application says how much it downloads before you install it. **Everything else, yourself.** It is your computer. `apt`, `pip`, `conda`, a tarball from somewhere, a git checkout you build — all of it works, and none of it is second class. Nothing about Hinode expects you to stay inside a list. ## Installing from Hinode Set up in your workspace. Render on a machine. You install applications from the catalog on the workspace and save them there. A machine starts from what you saved and does the rendering. To install, press Install on an application's card on the workspace screen in the Hinode app, run `hinode apps install comfyui` in a terminal, or ask your assistant. What an application needs comes with it: install ComfyUI and PyTorch installs first, and ComfyUI's card counts PyTorch in what it downloads. Install another while one is running and it waits its turn. It takes a few minutes, and you can keep working meanwhile. When it finishes, save a snapshot. A machine starts from the newest snapshot, so an application you installed after the last save is on the workspace and not on the next machine. The workspace screen and `hinode apps` both list what is not in a snapshot yet. Then attach a machine and open ComfyUI from that machine's Connect menu. ## Carrying it to other machines What you install on the workspace is what your machines start from. You capture it as a snapshot when you want one, and new machines start from the newest, so a machine you add for a big job already has your tools and your settings. Give each snapshot a line saying what changed — "torch 2.5 and the new LoRA nodes" — when you save it or any time after, and the list of versions reads as a history rather than as a column of numbers. So install there what every machine should have — a Python environment, the applications you use, your settings — and run the heavy work on a machine, since the workspace has only a small slice of a card. Anything you install on a machine stays on that machine, and goes when the machine does. If it is worth keeping, install it on the workspace and take a new snapshot. ## Where to put big files Models, datasets and output belong in the shared folder, which the workspace and every machine in it see and which no machine deletion touches. Environments, checkouts and anything made of many small files belong in your home folder, where they are fast. --- # Jobs Source: https://hinode.run/docs/jobs A job is one command handed to a machine, with an outcome you can read afterwards. It is how you start a training run and stop watching it. ## Starting one From a terminal, one command asks for a machine and runs your command on it: ```sh hinode run --size 48x64 "python train.py" ``` The size is graphics memory by system memory, and the command prints what that machine costs an hour before it starts anything. Add `-d` to hand the job over and get your terminal back; without it, the command follows the job to its end and exits with the job's own exit code. To use a machine you already have, name it instead of a size: ```sh hinode run --machine train "python eval.py" ``` The workspace screen lists jobs too, and an assistant connected to your account can submit one for you. ## One after another A machine starts every job you give it at once, side by side. To run one only after another has finished — train once the install is done — name the first job with `--after`: ```sh hinode run --machine train -d "pip install -r requirements.txt" hinode run --machine train -d --after "python train.py" ``` The second job waits as **Queued** and starts the moment the first one succeeds. If the first one fails or is cancelled, the second ends as **Failed** without running. The job it waits on can be on another machine in the same workspace, and a chain can be as long as you like. An assistant does the same when it submits a job, so it can queue the whole sequence and leave it running. ## While it runs The job runs whether or not anything is connected. Close the laptop; the machine keeps working. `hinode job logs -f` shows what the command is printing, live, from the machine. `hinode job list` shows every job in the workspace and how each one ended. `hinode job cancel ` stops it: the processes get a few seconds to write out what they have, and then they are stopped, so a cancel takes seconds rather than being instant. A running job counts as work, so the machine does not pause itself under it. That holds for a quiet job too: downloading a dataset with the graphics card idle is still work. ## How it ends A job waits as **Queued** while its machine is paused or starting, and while the job it runs after has not finished. Once it has run, it ends one of three ways: - **Succeeded** — the command exited with code zero. - **Failed** — the command exited with any other code, and the job shows it. Or the command never got to run — the machine stopped under it, or the job it was to run after did not succeed — and then the job says why and shows no exit code, because no program of yours returned one. - **Canceled** — you stopped it. Every job keeps how long it ran and the end of what it printed. The end of the log stays readable after the machine pauses itself and after the machine is deleted, because the machine sends it as it goes and again when the job ends. The whole log lives on the machine while the machine exists. ## After it ends The machine stays yours. It takes the next job without being set up again, and it pauses itself after 15 minutes with nothing running, so a job that ends at three in the morning stops billing shortly after, on its own. What the job wrote to the shared folder is there for every other machine in the workspace. What it wrote to the machine's home folder stays on that machine. ## Emails You get an email when a job that ran for more than a couple of minutes ends. Jobs that end around the same time arrive as one message. A job you cancelled is never emailed. `hinode job emails` changes that: `all` for every job, `long` for the default, `failures` for only the ones that failed, and `none` for silence. --- # What you pay for Source: https://hinode.run/docs/what-you-pay-for Hinode bills for what you run, after you have run it. There is no plan to pick and no allowance to use up. The prices below are what you will be charged. They are read from the same rate table as your invoice each time this page opens, and they change — so check them here rather than remembering them. ## The four things that bill **A computer that is running.** The workspace bills $0.297 an hour while it runs. Each machine you attached bills while it runs too, from $1.75 to $12.58 an hour, and machines are where most of the money goes. **What is on a disk, while the disk exists.** $0.15 per GB a month for what is written on it — not for a size anybody set aside. The workspace has a disk and so does every machine you attach, all at that rate, charged whether it is running or paused, because the files are kept either way. There is no disk size to choose and none to buy: a disk grows itself when it fills, and deleting files takes the bill down the next hour. Deleting a machine ends its disk; deleting the workspace ends the workspace's. **The shared folder**, at $0.10 per GB a month on what is written in it. Nothing is provisioned, so nothing is paid for until you put something there. **Traffic out**, at $0.10 per GB when something large leaves your workspace or a machine. Streaming a machine's desktop is not billed separately. ## Computers put themselves to sleep The workspace or a machine that nobody is working on pauses itself after 15 minutes. "Working on it" means what you would expect: input on the screen, the graphics card doing something, data leaving the machine — **or any process you started still running**, including one started over SSH and left behind. A quiet job is not idle: a training run that is downloading a dataset with the card at nothing counts as busy, and will not be paused underneath you. The other side of the same rule: something you forgot — a stuck script, a session you never closed — keeps the computer awake and billing. If one is not pausing when you expect it to, that is what to look for. Pausing stops the hourly charge. The disk stays, and so does everything on it. ## The budget You can set a monthly budget. It emails you when you are most of the way through it, and again when you reach it, and it stops nothing: work in progress is not killed and nothing is refused. It is a warning, not a brake — the brake is pausing or deleting the machines you are not using. ## When the workspace stops Besides a pause, Hinode stops the workspace when the credit runs out, and its machines pause with it. Nothing is deleted. Add credit and the workspace starts again by itself. ## What a bill looks like You pay before you use. Add credit from $10.00, and everything you run is paid from it by the minute. The first workspace starts once you add credit, from $10.00, and your first top-up gets $5.00 extra. Credit never expires, and there is nothing to cancel except what you created. Once a month you get an invoice itemised by what ran; the credit pays it, not your card. The workspace has its own line and so does each machine: with everything paused, a month costs the disks and the shared folder, nothing more. --- # Reaching your machine Source: https://hinode.run/docs/connecting Five ways in, and you will use more than one. ## The desktop Install the Hinode application on your Mac, Windows PC or Linux computer, sign in, and press Connect on the workspace or on a machine. Its desktop appears in a window: a full Ubuntu session with that computer's graphics card behind it. Or skip the install: sign in at hinode.run in Chrome or Edge on a computer and press Connect there, and the same desktop opens in a tab. Safari and Firefox cannot play the stream yet. The workspace's desktop runs on a small slice of a graphics card, which is plenty for files, a browser and an editor. For work that needs a whole card, connect to a machine. It needs a real computer with a keyboard and a mouse. A phone or a tablet cannot show the stream, in the app or in a browser. Everything else — seeing what is running, what it costs, pausing — works from anywhere. ## SSH Every workspace and every running machine answers at a stable name, so `ssh`, `scp`, `rsync` and `git` work the way they do with any server. Install the `hinode` command-line tool, sign in once and run its setup: it makes a key for this computer, registers it with your account, and writes the configuration, so connecting is `ssh yourworkspace` with nothing to paste. The application installs that tool for you, so signing in once in the app is usually all it takes. A paused **workspace** starts when you connect over SSH, and the connection waits for it. A paused **machine** does not, and that is deliberate: a large machine costs real money an hour, and typing `ssh` is not consent to spend it. Resume it first, and the connection works. ## An application in your own browser Some applications have a web interface, and you may want it beside your other tabs rather than inside a streamed window. `hinode open ` runs it on one of your machines: it starts the application if it is not running, forwards its port, and opens the tab on your own computer. The machine has to be running, so resume a paused one first. The tab works for as long as the command runs. This needs the desktop application or the command-line tool: the connection is a tunnel, so the port is never opened to the internet. ## An editor Visual Studio Code and anything else that speaks SSH connects straight to a workspace or a machine over the same name and the same key. You edit files where they live. Open a project on the workspace to work on it, and on a machine to run it on a graphics card. ## An assistant Claude and other assistants reach your account through Hinode's own connector. They read what you have, what is running and what it costs, and they do what you would do yourself: make a workspace, attach a machine, run a job on it, pause and resume it, delete it, set your budget. **In a browser.** Claude lists Hinode in its connector directory: find it in the connectors list in Claude, or open [claude.ai/directory/hinode](https://claude.ai/directory/hinode), add it and sign in. Nothing to paste. Anything else that takes a connector by address — ChatGPT among them — wants one address: `https://mcp.hinode.run`. Add it and sign in when it asks. If it offers you a choice of OAuth client, take the one that registers itself automatically — Hinode hands every assistant the same client, so there is nothing for you to fill in. Both this address and the configuration below are on your own Settings screen, under Connect an assistant, with a button that copies them. **On your own computer.** Claude Desktop, Claude Code, Codex — anything that loads a server of its own — runs the `hinode` command instead: ```json { "mcpServers": { "hinode": { "command": "hinode", "args": ["mcp"] } } } ``` Nothing to paste and no second sign-in: it works as you, on the sign-in `hinode login` already left on the machine. Use this rather than the address above when the assistant runs on your own computer — that sign-in comes back through a browser, and an assistant on your machine has nowhere for it to land. An assistant on your own computer also works on the machines themselves: it runs a command and tells you what came back, reads and writes files, and reads what a job has printed. It uses the key on this computer, so it reaches what you reach. A connector in a browser does none of that — there is no way in from our side. Ask it to run a job instead. A connected assistant appears in your Settings under Active devices, beside your own computers, and revoking it there signs it out. An assistant here spends real money, and it acts as you: it can start whatever you could start, and it is refused whatever you would be refused. Anything that starts a machine comes back with the price, and deleting one takes the machine's name typed again. --- # The hinode command Source: https://hinode.run/docs/command-line `hinode` runs on your own computer and does from a terminal what the application does with buttons: machines, jobs, applications, snapshots, spend, and SSH. ## Getting it The Hinode application for macOS, Windows and Linux carries the command and sets it up when you sign in, so if you have the application you already have `hinode`. It is one file with nothing else to install. On a computer without the application, such as a server, install the command alone. On macOS and Linux: ```sh curl -fsSL https://hinode.run/download/cli/$(uname -s)-$(uname -m) | tar -xz sudo mkdir -p /usr/local/bin && sudo mv hinode /usr/local/bin/ ``` On Windows, in PowerShell. It needs no administrator; open a new terminal afterwards, so it sees the new PATH: ```powershell $d = "$env:LOCALAPPDATA\Programs\hinode" iwr https://hinode.run/download/cli/windows-amd64 -OutFile "$env:TEMP\hinode.zip" Expand-Archive "$env:TEMP\hinode.zip" $d -Force $p = [Environment]::GetEnvironmentVariable("Path", "User") if ($p -notlike "*$d*") { [Environment]::SetEnvironmentVariable("Path", "$p;$d", "User") } ``` These always fetch the current version. Every build, with its checksum, is at https://hinode.run/download. Then sign in once: ```sh hinode login hinode ssh setup ``` `login` opens your browser. `ssh setup` makes a key for this computer, registers it with your account, and writes the SSH configuration, so `ssh` followed by a workspace or machine name connects with nothing to paste. Run `hinode ssh setup` again after you create, rename or delete something, and the configuration is rewritten. Where a command takes a workspace, you can leave it out when you have only one. ## Machines ```sh hinode machine sizes # every size, and its hourly price hinode machine quote 48x64 # the price, without starting it hinode machine add train --size 48x64 hinode machine list hinode machine pause train hinode machine resume train hinode machine rm train ``` A size is graphics memory by system memory. Anything that starts a machine prints its hourly price first. `rm` deletes the machine and what is on its own disk; the shared folder is untouched. ## Jobs ```sh hinode run --size 48x64 "python train.py" # wait for it hinode run --size 48x64 -d "python train.py" # come back later hinode run --machine train "python eval.py" # a machine you have hinode job list hinode job logs -f hinode job cancel hinode job emails failures ``` Without `-d`, `hinode run` exits with the job's own exit code, so it fits in a script. If you interrupt it (Ctrl-C, or a timeout in your script), the job keeps running and `hinode run` exits 130, so a script does not take it for a finished job. ## Applications and snapshots ```sh hinode apps catalog # what there is to install hinode apps install comfyui # install on the workspace hinode apps # what is installed and not saved hinode env promote --description "ComfyUI and new nodes" hinode env list hinode open comfyui --machine train ``` `hinode open` starts an application on a running machine, forwards its port to this computer, and opens it in your browser. The port is never opened to the internet, and the tab works for as long as the command runs. Add `--install` to install the application first. ## The workspace and your spend ```sh hinode list # your workspaces and their addresses hinode pause # stop the workspace; machines keep running hinode resume hinode disk # the workspace's disk, and what it costs hinode spend # what everything running costs an hour ``` `ssh` to a paused workspace starts it and waits. `ssh` to a paused machine does not: a machine costs real money an hour, so resuming one is always something you ask for. ## For assistants and scripts `hinode mcp` connects an assistant on this computer to your account; it is not something you run by hand. `hinode open` writes progress to the terminal and a line of JSON per step to its output, so a program can follow it. --- # Hinode in your assistant Source: https://hinode.run/docs/assistants Claude, ChatGPT, Codex and other assistants can work your Hinode account: say what you need, and they attach the machine, run the job and tell you what it cost. ## What an assistant can do It reads what you would look at yourself: prices, your workspaces, their machines, jobs and their logs, what you are spending, and these documents. It does what you would do yourself: create, rename and delete a workspace, pause and resume the workspace, attach a machine, pause, resume and delete it, submit and cancel a job, install applications, save a snapshot, and set your monthly budget. Every price it quotes comes from Hinode at the moment it answers, not from its memory. It waits for results in the same conversation: a machine or the workspace coming up, a job ending, an install finishing, a snapshot being saved. It cannot come back to the conversation later on its own, so for work that runs for hours it queues the next step to start when the current one succeeds, and you get an email when a job ends. ## In a browser Claude lists Hinode in its connector directory: find it in the connectors list in Claude, or open [claude.ai/directory/hinode](https://claude.ai/directory/hinode), and there is nothing to paste. ChatGPT, and anything else that takes a connector by address, wants one address: ```text https://mcp.hinode.run ``` Add it as a connector and sign in when it asks. If you are offered a choice of OAuth client, take the one that registers itself: there is nothing to fill in. Your Settings screen shows both the directory link and this address under Connect an assistant, with a button that copies them. ## On your own computer Claude Desktop, Claude Code, Codex and anything else that runs a server of its own use the `hinode` command instead: ```json { "mcpServers": { "hinode": { "command": "hinode", "args": ["mcp"] } } } ``` There is no token to paste and no second sign-in: it works as you, on the sign-in the Hinode application or `hinode login` already left on this computer. An assistant set up this way also works on the machines themselves. It runs a command and reports what came back, reads and writes files, and reads a job's log straight from the machine. It uses this computer's key, so it reaches exactly what you reach, and a command it runs is stopped after a couple of minutes — longer work goes in as a job. A connector in a browser cannot reach inside a machine, because Hinode has no way in from its side. Ask it to run a job instead. ## Money and safety An assistant acts as you. It can start whatever you could start, and it is refused whatever you would be refused. Nothing limits it beyond what limits you: the credit, which pauses everything when it reaches zero; your monthly budget, which emails you and stops nothing; and machines pausing themselves after 15 minutes with nothing running. Anything that starts a machine comes back with its hourly price, from $1.75 to $12.58. Deleting a machine or a workspace needs its name typed again. A machine records which assistant started it. ## Signing an assistant out A connected assistant appears in Settings under Active devices, beside your own computers. Revoke it there and it is signed out. --- # Many machines at once Source: https://hinode.run/docs/many-machines Split a dataset into parts, start one job per part, and each job gets its own machine. All of them read the same shared folder. This is how you run a model over more data than one card gets through in a day: labeling, captioning, classification, scoring, embeddings. ## How it works 1. **Set up once, on the workspace.** Install what the job needs — vLLM, Ollama, PyTorch or your own environment — and save a snapshot. Every machine starts from it. 2. **Put the dataset in the shared folder.** Every machine reads the same copy. Nothing is uploaded per machine. 3. **Start one job per part.** Each `hinode run --size` attaches a new machine and runs the command on it. 4. **Write results to the shared folder.** When a job ends, its machine pauses itself after 15 minutes with nothing running. ## Splitting the work Hinode does not split your dataset. Each job is a command, and the command says which part it takes. Pass the part as an argument: ```sh for i in 0 1 2 3 4 5 6 7; do hinode run --size 24x32 --name label-$i -d "python label.py --part $i --of 8" done ``` That is eight machines, named `label-0` to `label-7`, each running the same script on its own part. The script picks its files by the part number — every eighth file, starting at its own — and writes its results to a file of its own, such as `~/shared/out/part-3.jsonl`. Two jobs never write to the same file. Read the files several at a time: a PyTorch `DataLoader` with `num_workers` does it, or a thread pool. A machine fetches each file over the network the first time it reads it, and on a folder of small files, sixteen reads at a time went fifteen times faster than one after another. Every command prints the machine's hourly price before the machine starts. Make the script skip items that already have a result. Then a rerun picks up where the last run stopped instead of starting over. ## Watching them `hinode job list` shows every job in the workspace and how each one ended. `hinode job logs -f` follows one live. The jobs run whether or not your computer is on. When a job that ran for more than a couple of minutes ends, you get an email. Jobs that end around the same time arrive as one message, so eight parts finishing together are one email, not eight. ## When one part fails Only that part runs again. Its machine still has everything installed, so resume it and give it the same command: ```sh hinode machine resume label-3 hinode run --machine label-3 -d "python label.py --part 3 --of 8" ``` A job given to a paused machine waits as **Queued** and runs when the machine is resumed. ## A step that needs a bigger card Give the heavy step a bigger machine. To start it only after another job succeeds, name that job with `--after`: ```sh hinode run --size 48x64 -d --after "python score.py" ``` `--after` names one job. For a step that needs every part done, start it once `hinode job list` shows all of them as **Succeeded**, or ask an assistant to wait for them and start it. ## What it costs Each machine bills by the minute while it runs, at its own rate. The cheapest is $1.75 an hour. Eight machines for an hour cost the same as one machine for eight hours, plus the minutes each one takes to start. So splitting the work buys time, not a bigger bill. A machine stops billing for compute when it pauses. Its disk bills for what is on it at $0.15 per GB a month until you delete the machine. Delete them when the run is done: `hinode machine rm label-3`. The shared folder, and the results in it, stay. ## How many machines A new account has one machine, paused ones included, and the limit grows as you pay. Delete a machine you are done with to attach another. If a region has no card of the size you asked for, the machine waits, tries again, and says until when. You can pick another size meanwhile. ## Letting an assistant run it An assistant connected to your account can do all of this: attach the machines, start a job on each, wait for them, and tell you when the last one ends. Ask it in your own words — "label every image in `~/shared/frames` on eight of the smallest machines" — and it quotes the hourly price before it starts anything. --- ## The application - [Download](https://hinode.run/download.md): the desktop application for macOS, Windows and Linux, and what each one needs - [ComfyUI in the cloud](https://hinode.run/comfyui-cloud): ComfyUI on a cloud GPU with up to 96 GB of VRAM that keeps custom nodes, models and LoRAs between sessions, opened in a browser on a Mac or PC - [Batch inference on cloud GPUs](https://hinode.run/batch-inference): running an open model over a whole dataset on many machines at once: one job per part, one shared folder, each machine pausing itself when its part is done - [Cloud GPU prices and features, compared](https://hinode.run/compare): Hinode next to RunPod, Vast.ai and Google Colab: the price of an hour by card, what a stopped machine costs, what is kept when you stop, and who should rent elsewhere - [A RunPod alternative that keeps your setup](https://hinode.run/runpod-alternative): Hinode and RunPod line by line: hourly prices, disk and traffic, what happens on stop, and when to use each - [Release notes](https://hinode.run/blog/releases): what changed in each version of the apps, the website and the command line ## Optional - [Blog](https://hinode.run/blog): articles about what Hinode can do, and news from the team - [Terms of Service](https://hinode.run/terms.md): the terms that govern using Hinode - [Privacy Policy](https://hinode.run/privacy.md): what is collected, why, and the choices you have - [Deleting your account](https://hinode.run/delete-account): how to close an account and what goes with it - [Hinode now runs on credit you add](https://hinode.run/blog/hinode-runs-on-credit): Prepaid cloud GPU: add credit from $10, and every machine is paid from it. At $0 machines pause and keep their disks. Auto-recharge is optional. - [Work on Hinode as a team](https://hinode.run/blog/work-on-hinode-as-a-team): Share a cloud GPU workspace with your team. Invite people by email, choose the workspaces each one can use, and pay with one card and one monthly invoice. - [Hinode v3: set up once, run on any GPU](https://hinode.run/blog/hinode-3): Hinode v3 is a cloud GPU workstation for AI creators: set up ComfyUI once, then run it on GPUs from 24 to 96 GB of VRAM that pause themselves. - [Ask Claude to start the run](https://hinode.run/blog/ask-claude-to-start-the-run): Add Hinode to Claude and run GPU jobs from chat. Claude picks a cloud GPU, starts your LoRA training or ComfyUI job, and tells you when it ends. - [One workspace, many machines](https://hinode.run/blog/one-workspace-many-machines): Set up ComfyUI and your Python environment once. Every cloud GPU you start, from 24 to 96 GB of VRAM, opens with the same apps and the same files. - [Pick the card the model needs](https://hinode.run/blog/pick-the-card-the-model-needs): Out of VRAM? Rent a cloud GPU with 24, 48 or 96 GB of VRAM and 32 to 256 GB of RAM: L4, L40S or RTX PRO 6000, with your apps already on it. - [Install ComfyUI in one click](https://hinode.run/blog/install-comfyui-in-one-click): Install ComfyUI on a cloud GPU in one click, with PyTorch and CUDA set up for you. Save a snapshot, and every new GPU machine starts with it. - [One folder for every machine](https://hinode.run/blog/one-folder-for-every-machine): Download models once. The shared folder holds your checkpoints, LoRAs and datasets, and every cloud GPU machine in the workspace reads them. - [Start a training run and go to bed](https://hinode.run/blog/start-a-training-run-and-go-to-bed): Train a LoRA overnight on a cloud GPU. One command starts the job, you get an email when it ends, and the machine pauses itself so billing stops. - [Idle machines pause themselves](https://hinode.run/blog/idle-machines-pause-themselves): Stop paying for an idle GPU. A Hinode machine pauses itself after 15 quiet minutes and keeps its disk. A running job or open ComfyUI tab keeps it awake.