Omniscio

Cloud Runner (run a session on a cloud machine)

Cloud Runner runs a session on a cloud machine instead of your computer, so the work keeps going while your laptop is closed. You turn it on once, pick Cloud in the Run chip on a new session, and from then on you read, reply, approve and stop that session here exactly as you would one running on another of your own computers. Every turn's code and conversation are copied to the cloud, so a machine that dies loses nothing, and the work comes home here to land.

On this page

What it is

A cloud machine that Omniscio starts, treats as one more of your computers, and lets you drive from this one. You do not open it, install anything on it or type a code: pick Cloud, send your first message, and the session is running there.

Each session gets its own machine, so one session's files and secrets are never another's. The machines belong to one separate cloud service of ours that buys, wakes, stops and deletes them; this computer never holds the key to that account and can only ask it for a machine.

Everything else you already know still applies. The session appears in its own project here like any other, you read it here, reply here, approve its permission asks here, and stop it here.

Where to find it

  • Turn it on — Dev Pipeline panel, Setup tab, the All settings view, then the Cloud Runner card. It is off until you switch it on. Searching Settings for "Cloud Runner", or a link to that setting, opens the panel there with the card open and the switch in view.
  • Add your Claude key — the same card, just below the switch: paste your Claude API key once and press Save. On an account that pays for its own sessions, this key is what pays for them. The card then reads "Saved — the key ends in …" so you can tell a key is in there without the key itself ever being shown again. An account Omniscio pays for needs no key: its sessions use the Cloud Runner workspace's own key, and the card can be left empty.
  • Start a session there — the Run chip on a brand new session. Cloud sits beside Local and beside any other computer of yours, and reads "Runs on a cloud VM".
  • What it needs alongside it — Settings → Remote Access → Link my computers, which must be on. Cloud Runner drives a cloud machine the same way it drives one of your own computers, and that is the switch that allows it.
  • A session running there — an ordinary row in its project, marked with the computer that runs it. The row reads "On Cloud", or "On Cloud, which is offline right now" while the machine is asleep, and the session's header reads "Runs on Cloud".
  • Its work coming home — the same note any of your other computers' sessions carry in the session's header: "Waiting to come home", "Coming home", "Landed on … master as …" with the commit, or "Could not come home: …" with the reason. The session list does not show it.

Trying it for the first time

A short walk through your first Cloud session, for an account the Cloud Runner service has already turned on. Today that is the owner's own account and the crew's test accounts; no other account is turned on yet.

1. Switch it on (one setting). Set Cloud Runner to Auto on the Cloud Runner card (Dev Pipeline panel, Setup tab, All settings). Auto asks our cloud service whether your account may use it, so it turns on for an account on its list and stays off for everyone else. Nothing needs a restart. Link my computers must also be on; if it is off, the first launch says so in plain words. Mobile Access does not have to be on for a cloud machine.

2. Start a session in the cloud. Open a project that has a git remote, start a new session, and click the Run chip above the message box. Pick Cloud ("Runs on a cloud VM"). The first time, Omniscio asks you once to confirm that this runs on a paid cloud machine. Then type your first message and send it. Cloud sessions run Claude Code only.

3. What you should see. The session row reads "On Cloud" and the header reads "Runs on Cloud". The first message takes longer than later ones, because a machine is woken or bought and gets its copy of your project first; on a ready machine the crew's test runs (launch, two turns and the work coming home) finished in about a minute and a half. If placing it takes longer than five minutes, you are told it did not finish in time and to try again, and nothing runs twice. After that, replies, permission asks, the model picker and Stop work exactly as on this computer.

4. Closing your laptop is fine. The session keeps going in the cloud. A machine with nothing to do for ten minutes saves everything and stops itself; the row then reads "On Cloud, which is offline right now", and a quiet line above the conversation says "This cloud machine is asleep. It wakes when you reply." The turns this computer already holds stay on screen, and looking at the session never wakes the machine. Sending a reply wakes the machine and the session carries on from where it was.

4a. The conversation is still there after you quit and reopen Omniscio. What this computer holds of a cloud session lives only in the open app, so a restart used to leave a stopped session showing the asleep line over an empty screen. Now the session's conversation is read from the same cloud copy its work comes from — the one the machine writes after every turn — so it opens with its whole history and the asleep line above it. It is read at most once per session per change: the app asks the cloud copy which version it holds, and re-reads the conversation only when that version has moved, so a restart is the only thing you pay for. If the cloud copy has nothing for that session yet, or it cannot be read, you get the same single asleep line and no error. Looking at a stopped session still never wakes its machine.

A cloud turn reads exactly like a turn on this computer: the agent's answer is drawn with its working steps — each tool it used and each result it got — folded into the activity pill beside it, and the short lines the agent writes between those steps stay on that turn instead of one of them disappearing.

5. Where your work is saved, and how it comes home. After every turn the session's code and conversation are copied to a vault in the cloud under your account, so a machine that dies loses nothing. The work comes home to this computer on its own when the session marks its work ready, or when you archive it; there is no button to press. It then lands here through the same checks as work from any of your other computers, and the session's header reads "Landed on … master as …". A project that finishes with a pull request gets a pull request instead of a landing, as described under "Where pull requests come from" below.

6. What it costs, and the limits. A machine costs money only while it is awake; a stopped one costs only its disk. On an account Omniscio pays for, no Claude key is needed and nothing is charged to you. Total spend is capped at $250 a month: $200 for machines, which is Cloud Runner's own limit (it refuses new sessions and wakes, with a plain reason, once a month's machine spend reaches it), and $50 for the Claude key. The Cloud Runner card shows this month's spend against the ceiling and each machine's load. You also get one inbox card, once a month, the first time the month's machine spend reaches 80% of that $200, so you hear before new sessions stop.

7. Not supported yet. Engines other than Claude Code; restarting a running session or changing its thinking level while it runs; jumping to an older part of a long conversation; moving a session to another machine. A subscription sign-in keeps a cloud session going only while this computer is open; an API key or an account Omniscio pays for has no such limit.

How it behaves

  • One switch, three states, and it is off by default. Off means Cloud in the Run chip starts nothing on Cloud Runner, no machine is registered, and no call to our cloud service leaves this computer. On lets Cloud ask for a cloud machine. Auto asks our cloud service whether this account may use Cloud Runner and follows that answer, so who gets Cloud Runner is decided there rather than by an app update. No address needs setting on your computer: with Auto or On the app uses the Cloud Runner service directly, and a field on that setting only overrides which one.

  • Your Claude key is yours alone. It is stored encrypted on this computer and it is never shown again after you save it. A Cloud session gets it only for the machine that runs that session, and no other computer or session sees it. A Claude API key starts with sk-ant-api; a Claude sign-in token (one starting sk-ant-oat) is refused with a plain sentence, because a sign-in token cannot be handed to a cloud machine. A Cloud launch with no key to use is refused with "Cloud sessions have no Claude key yet", and nothing starts.

  • A running Cloud session streams as it works. While the machine is running a turn, its answers land in the conversation as it writes them, rather than all at once when the turn ends, and you see the agent and your own echoed message in the order they happened — the same live output you get from a session running on this computer. A machine that is asleep sends nothing, so the session shows its saved conversation until it wakes; the stream resumes on the reply that wakes it.

  • Picking Cloud spins nothing up. The pick is only a pick. Your first message is what starts the session: this computer asks the cloud service for a machine with room, a machine is woken or bought, a copy of your project goes up, the machine is linked here as one more computer, and the session starts there. From your side nothing else changes, and every reply, approval, model pick and Stop works exactly as it does on a session running on another of your computers. A machine that has gone to sleep counts as empty, whatever it last reported, so a first message is never turned away as "full" by an idle machine, and a message that does not fit is turned away before any machine is woken or billed.

  • The first Cloud pick asks once, in plain words. The Cloud row warns that it runs on a paid cloud machine, and the first time you pick it Omniscio confirms that before anything is staged. The answer is remembered, so it is asked once and not on every session.

  • A project needs a git remote. A cloud machine gets its copy of the project from that remote. A project without one is refused with "This project has no git remote, so a cloud machine cannot get a copy of it." The launch never quietly runs it here instead.

  • Once a session has a conversation, its place is fixed. The Run chip only appears on a blank session, so a session cannot be moved to another machine halfway through.

  • While this computer is closed, nothing stops. The session keeps running, its permission asks wait for you, and its work waits in the cloud. When you come back, nothing that happened is missing.

  • A machine with nothing left to do stops itself. Once nothing on it has been working for ten minutes, it saves every session, seals the machine and stops. A session waiting on you does not count as working, so it will not hold a machine awake all night. A stopped machine keeps its disk, so it costs only storage while it is stopped. The cloud provider's own automatic sleep is switched off on these machines on purpose, because it would sleep in the middle of a turn whenever your laptop is shut.

  • Waking is a reply. While a machine is asleep its session reads "On Cloud, which is offline right now", with a quiet line above the conversation: "This cloud machine is asleep. It wakes when you reply." Opening the session, coming back to it and every background refresh never wake the machine. The conversation itself is read from the machine's cloud copy, never from the machine, so it is all there even after the app restarts; when a newer copy exists than the one already read it is shown, and when there is none the asleep line is the only thing above an empty screen. Send a reply and the machine wakes, the session picks itself up from the cloud copy, and your reply is delivered once, with its conversation and any approval that was still waiting. Only a reply wakes a session; an approval for a question a woken session never asked is refused. A link that drops does not wake one either: Omniscio re-checks which machines are awake before it reconnects, so catching up with a connection that went away never switches a stopped machine back on.

  • A turn cut off by a crash comes back interrupted. If a machine stops uncleanly in the middle of a turn, its session comes back marked interrupted and is never restarted on its own, so no command runs twice. Reply to continue. If a cloud session's process stops, it shows as interrupted; reply to continue it.

  • Every turn's work is copied to the cloud. After each turn the session's code and its conversation are written to a vault in the cloud under your own account. This is a separate store from the Vault of notes you keep in Omniscio, and it holds nothing but a session's own code and conversation. Each copy is checked against its own fingerprints before it is used, and the previous one is kept until the newer one is safely in place, so a machine that dies mid-write still leaves a good copy behind. The copies are deleted thirty days after a session is archived and its work has landed, and at once if the account is erased.

  • The work comes home here to land. Work never lands on the cloud machine. When the session marks its work ready, or when you archive it, this computer fetches only that session's own change from the cloud over short-lived signed links, checks it arrived whole, builds the commit here, and lands it here through the same checks as work coming back from any of your other computers. The machine does not need to be awake for any of it, and it deletes its own copy only once this computer confirms it holds that exact commit.

  • Where pull requests come from. If a project's own finishing choice is "Open a pull request", the work from a cloud session comes home onto a branch of its own on this computer and is never put on your main branch. This computer then opens the pull request, with the project's own command and your own GitHub sign-in on this computer; the cloud machine never gets GitHub access and no GitHub sign-in is ever sent to it. The session shows one plain note saying where the work is and, when it worked, the link. When the project asks you to approve first, when the change touches files that run by themselves (workflows, hooks, settings) or would delete files your main branch has, when the project names no command for opening one, or when the command fails or runs out of time, nothing is opened: the work stays on its branch and the note says how to open it. If the app closes while a pull request is being opened, the note at the next start says it may not have been opened. A later turn of the same session adds to the same branch, even when it changes or undoes what an earlier turn did, so the open pull request updates and a second one is never opened; if a newer turn arrives while an older one is still waiting its turn, only the newer work is published. Anything you commit to that branch on this computer is kept; if a later turn changes the same lines, the work is not added and the note names the files. If you reword or rebase that branch, later turns still add to it; if this computer can no longer tell which turn it last brought home and the cloud work has changed, nothing is added and the note says the work clashes. If the project's finishing setting cannot be read at that moment, the work waits and is retried; it is never landed on a guess.

  • Your own Claude key, if the machine is yours to pay for. When Cloud Runner runs on your own key, you paste that Claude API key once and it stays on this computer, encrypted. When you start a session, this computer hands the key to that machine over the private link it already uses, never through our cloud service, and only after the machine confirms it has it. Starting that session again reuses the same key version, so a retry never quietly changes which key it got, and a key you replace later is a newer version that takes effect when the session next starts. A machine Omniscio itself pays for keeps using the workspace key, as it does today. If you have not added a key, the launch is refused in plain words before any machine is asked for. Cloud Runner wants an API key, not a subscription sign-in — pasting a sign-in token is refused with a sentence saying so.

  • What it costs. A machine is paid for only while it is awake; a stopped one costs just its disk, and a session with nothing to do stops itself, so an idle session stops costing machine time. An API key or managed credit is spent the same way as here. Spending is bounded by the budget on the workspace that runs Cloud Runner: a launch that would take spend past what is left is refused with that reason and nothing starts, and when the budget is used up the machines stop themselves after you are told. How many machines may run at once follows how much has been added to that workspace: 3 before any top-up, 10 after the first, 50 at $50 or more, 200 at $250 or more and 1,000 at $1,000 or more, and that number never goes down. Those are on-demand machines with disks that survive a stop, never cheaper machines the provider may reclaim and wipe.

    • See the cost. The Cloud Runner card on the Dev Pipeline panel's Setup tab shows what this month has cost so far against the ceiling, with a plain warning as it nears the ceiling, so you see the spend before the ceiling stops new sessions. It also shows each machine's load and warns when a machine's heartbeat has gone quiet.
    • Hear it at 80%. On an account Omniscio pays for, you get one inbox card per month the first time the whole month's machine spend reaches 80% of the $200 machine ceiling, for example "$160.00 of the $200.00 Cloud Runner machine budget is used this month". It says what happens when the budget is used up: your cloud machines drain (they stop taking new work, save their sessions and shut down), and no new machine can be bought or woken until the budget resets next month. It asks you to do nothing, so it has no button, and you can switch that card type off in the alert settings.
    • Two different 80% numbers. The inbox card is about the whole workspace against the service-wide $200 ceiling, while the Cloud Runner card shows its own warning once this account's spend passes 80% of this account's own monthly ceiling. On a given day they can disagree (a warning on the card with no inbox card, or the reverse), and each is right for its own job.
    • When it can and cannot warn. The card rides the same spend read the Cloud Runner card uses, so it can only appear while Cloud Runner is switched on for you and the app is running. That read repeats every two minutes while linked computers are on. With linking off it happens only when you open a screen that shows the Cloud Runner card or the Run chip, once per opening. A closed app cannot warn you. The month it last warned about is saved on this computer, so a restart does not repeat it; if that file is lost, the card can come back once in the same month, folded into the earlier card while that one is still open.
  • What version 1 cannot do yet.

    • Claude Code only. Any other engine is refused with "Cloud sessions run Claude Code in version 1 — pick Claude for this session."
    • A subscription sign-in lasts only while this computer is open. An API key or managed credit has no such limit. When a subscription lapses the session pauses and says "Open Omniscio to keep your cloud sessions going".
    • A running session cannot be restarted from here yet, and its model's thinking level cannot be changed while it is running.
    • Only the newest part of a long conversation is available. The machine sends what it still holds, and when that is less than the whole conversation the session opens with one line saying how many entries were left out. Jumping to an older part of a conversation is not there yet.
    • A session cannot be moved to another machine or to another engine.
  • Refusals are always in words, and nothing falls back. A launch that cannot go ahead is refused with its reason instead of running on this computer or on another route. The reasons you may meet are "Cloud Runner is off on this computer.", "Turn on "Link my computers" to run a session on a cloud machine.", "This computer could not give the cloud machine a copy of this project, so nothing started.", "The cloud machine could not be reached, so nothing started.", "Cloud Runner could not be reached, so nothing started. Check this computer is online and try again.", "The cloud controller did not finish placing this session in time. Try again in a moment.", "No cloud machine was placed for this session, so nothing started and nothing will retry on its own. Try again in a moment." and "The cloud machine did not answer, so it is not known whether the session started." That last one is the only case where Omniscio tells you it does not know: the launch is made good when the machine answers again, and it never runs twice.

  • An answered launch that names no machine opens no link. When the controller answers the launch itself and that answer carries no machine, the launch stops there: nothing is placed, no machine is contacted, nothing waits on a link, and you read the sentence above rather than a close code from a connection the launch never should have made. The two other answers are kept apart from it: a buying or waking answer means the controller is still placing the session and it is asked again until the placement deadline, and a refusal with a reason gets the plain refusals below.

  • A refusal from the Cloud Runner service is said in plain words. Your cloud machine limit is reached, your Cloud Runner spending limit for the month is reached, no cloud machine is available, every cloud machine is full, the provider did not accept the request, your Omniscio sign-in has expired, cloud sessions have no Claude key yet, a subscription token was pasted where an API key is needed, and a pasted value is not a Claude API key each get their own sentence with what to do next. The service's own words are kept only when they are already plain and short; anything raw (an HTTP status, a provider body, a stack frame) is written to the log instead and you see one plain sentence.

  • A machine that is still coming up holds your message instead of bouncing it. Picking Cloud and sending a first message while the controller is still bringing a machine up no longer sends that message back into the composer. It is kept and offered again until a machine takes it — about six minutes' worth of trying — and the session panel shows "Provisioning cloud VM…" while it waits, so the wait is something you can see instead of a panel that looks frozen. A machine that has still not come up by then says so in its own words: "No cloud machine became ready for this session in time, so nothing started. Try again in a few minutes." Your message is sent once, never twice, and only a "not yet" answer is waited on — a spending limit, a machine limit or any other final answer still tells you straight away.

  • A turn the cloud could not save tells you in the session. When a turn finishes but cannot be copied to the cloud, the session shows one line in its conversation: "This turn finished, but it is not saved to the cloud yet. It will be saved with the session's next turn." The session reads as failed until the cloud takes the work, then goes back to waiting for you. Repeats within ten minutes show as one line, and it is always Omniscio's own sentence, never the machine's wording. The conversation is held on the machine, so after you restart Omniscio you see the failed status without the line; the next turn saves everything.

  • A full cloud storage tells you the same way. When your cloud storage is full the machine stops copying turns, and the session shows one line: "Cloud storage for this account is full, so this turn is not saved yet. Free space by letting finished cloud work come home, or raise the storage limit, and it will be saved by itself." While there is no room the session reads as waiting, or keeps whatever it was already asking of you, and once there is room the cloud copy catches up with no action from you. The line comes from a signal the cloud machine sends, so a machine that has not updated its Runner yet still stops copying turns when the storage is full but shows no line here until it updates.

Other computers covers running a session on one of your own desktops, which is the same journey Cloud Runner makes with a machine you do not own: the same Run chip, the same mirror rows, the same approvals, the same work coming home. Cloud returned work covers what happens on this computer when a session's work arrives from elsewhere and how it lands. SSH remote covers the third place a session can run, a server you already have, which you reach with your own key instead of our cloud service.

Last verified 2026-11-16