Skill

spin up an orgo computer and screenshot the orgo.ai homepage

open chrome on my orgo computer, sign into github, take a screenshot

test how my dev server renders at https://localhost:3000 on a real browser

rm -rf ~/.claude/skills/computer       # personal install
rm -rf .claude/skills/computer         # project install

---
name: computer
description: Spin up a real cloud Linux desktop with Chrome and drive it from the terminal - clicks, types, screenshots, bash, multi-step AI agent runs. Backed by Orgo (orgo.ai).
when_to_use: Use when the user wants to automate desktop or browser tasks, run an AI agent on its own VM, take screenshots of a real Chrome page, test a website visually in a real browser, sandbox an installer or untrusted code, or have a computer that stays online across sessions. Trigger phrases include "open chrome", "screenshot the page", "sandbox this", "automate this site", "run an agent on a VM", "test on a real browser".
---

# Computer

This skill gives you a real cloud Linux desktop you can drive from the terminal. Each computer is online in seconds, has Chrome and the standard userland, and stays running until you stop it. Backed by Orgo (https://orgo.ai) - one CLI, one API.

Use this skill any time the user wants something that needs a real GUI: browser automation, visual testing, running an agent on its own desktop, sandboxing untrusted software, or any "open a page and do X" task that doesn't fit a single curl or local script.

## Install once

```bash
curl -fsSL https://orgo.ai/install.sh | bash   # installs Node + the orgo CLI
orgo login                                      # device-code OAuth in the browser
```

If the user already has Node 20+: `npm install -g orgo` instead.

Confirm with `orgo --version`. If `command not found`, add `~/.local/bin` to the user's shell PATH - the installer prints the exact line.

## Common workflows

### One-shot: have the agent drive the computer for you

```bash
orgo run "open chrome and screenshot the orgo.ai homepage" --computer agent-1
```

Streams text + tool calls + tool results to stdout. Add `--json` for a single structured object at the end:

```bash
orgo run "find the current plan pricing on orgo.ai" --computer agent-1 --json
# → {"text": "...", "tool_calls": [...], "tool_results": [...], "errors": [...], "computer": {...}}
```

### Interactive agent with persistent history

```bash
orgo agent --computer agent-1
```

Inside the TUI, slash commands: /help, /computer, /model, /sessions, /resume, /compact, /usage, /screenshot. Sessions auto-save to ~/.orgo/sessions/ after every turn - resume later with `orgo resume`.

### Direct shell on the VM

```bash
orgo ssh agent-1
# Lands in /root/Desktop. Disconnect with ~. (at line start) or Ctrl+C Ctrl+C.
```

### Provision a fresh computer

```bash
orgo computers create                             # interactive picker (workspace, name, RAM, CPU)
orgo computers create --name agent-1 --ram 4 --cpu 1
orgo computers list                               # see what's running
```

## When this skill is the right tool

Reach for this skill when the task needs a real GUI or a persistent computer:

- "Open this URL in Chrome and tell me what's on the page" - visual content the Read tool can't see.
- "Sign into X and click through Y" - real session cookies, not headless.
- "Test how this CSS change looks" - screenshot a dev server through a real browser.
- "Run an agent on a long-running task and check back on it later" - sessions outlive your terminal.
- "Try this installer / run this untrusted binary" - sandboxed from the user's machine.

## When NOT to use this skill

Don't spin up a cloud computer for things the user already has tools for:

- Reading local files → Read tool.
- Editing local files → Edit tool.
- One-shot HTTP / API requests → Bash + curl.
- Code you can write and run locally in Node/Python.
- Anything you can answer from training data.

A good check: does the task need vision of a rendered page, persistence across sessions, or isolation from the user's machine? If none of those, skip this skill.

## Plan awareness

Orgo plans are subscriptions, and each one caps how many computers you can have at once. Computers are persistent - there's no per-hour metering - but every computer counts against that cap until you delete it, whether it is running or stopped. Current caps are at [orgo.ai/pricing](https://www.orgo.ai/pricing).

What that means in practice:

- Reuse before provisioning. Run `orgo computers list` first.
- Delete throwaways with `orgo computers delete <name> --yes` when the task is done. Stopping doesn't free the slot.
- Agent calls (`orgo run`, `orgo agent`) draw on your plan's monthly AI credit. The default model is Sonnet 5; switch to Opus 5 (`--model claude-opus-5`) only for the hardest tasks, since long Opus runs cost more.

## Notes

- Every command accepts `--help` and `--json`.
- TTY detection switches the CLI to plain text when stdout isn't a terminal. Add `--json` when a program reads the output.
- Credentials live in ~/.orgo/credentials.json (mode 0600). Use ORGO_PROFILE=<name> to switch identities.
- Full docs: https://docs.orgo.ai. CLI reference: https://docs.orgo.ai/guides/cli.