Przejdź do treści
Biblioteka skilli
AI i agenci · Automatyzacja

leverage-cloud-agents

/leverage-cloud-agents

Konfiguruje Leverage Computer, czyli wspólne miejsce pracy agentów w chmurze dla Claude Code i Codex, i uruchamia pierwsze zadanie użytkownika.

Repozytorium
skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
09.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
9
Przestarzałość

Brak sygnałów. Repozytorium zmienione 09.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Konfiguruje Leverage Computer, czyli wspólne miejsce pracy agentów w chmurze dla Claude Code i Codex, i uruchamia pierwsze zadanie użytkownika.

Wyzwalacze z opisu

s first task there. Use when the user sayscloud agentskeep my agent running when I close my laptopsomething like Codex cloud or Claude Code on the webset up Leveragesign up for Leverageinstall the leverage CLI
Oryginalny opis (EN)

Sets up Leverage Computer, the team agent workspace, so Claude Code and Codex run on persistent cloud machines, then runs the user's first task there. Use when the user says "run Claude Code in the cloud", "cloud agents", "keep my agent running when I close my laptop", "something like Codex cloud or Claude Code on the web", "set up Leverage", "sign up for Leverage" or "install the leverage CLI". The other leverage-computer skills hand off here for signup and onboarding.

Jak działa

  1. Step 1. Install the CLI
  2. Step 2. Load the onboarding playbook
  3. Step 3. Account (a person signs up)
  4. Step 4. Sign in the CLI (a person approves)
  5. Step 5. Plan, approval, apply, activation
  6. Step 6. Owner setup (a few switches in Settings)
  7. Step 7. First real task on a Leverage computer
  8. Step 8. Bring in the team
  9. Where agents get stuck
  10. Ground rules
Sekcje z nagłówków SKILL.md, w oryginale · 303 linii, 2 293 słów
Podgląd SKILL.md
---
name: leverage-cloud-agents
description: >-
  Sets up Leverage Computer, the team agent workspace, so Claude Code and
  Codex run on persistent cloud machines, then runs the user's first task
  there. Use when the user says "run Claude Code in the cloud", "cloud
  agents", "keep my agent running when I close my laptop", "something like
  Codex cloud or Claude Code on the web", "set up Leverage", "sign up for
  Leverage" or "install the leverage CLI". The other leverage-computer skills
  hand off here for signup and onboarding.
license: MIT
compatibility: >-
  macOS and Linux (arm64, x64) with a shell, curl and network access to
  app.leverage.computer. A person must be present to sign up and approve
  sign-in in a browser. No Windows CLI; Windows users can use the web app.
metadata:
  author: leverage-computer
  homepage: https://leverage.computer
---

# Get started with Leverage Computer

Leverage Computer is the team agent workspace: one persistent computer for a
team and its AI agents.

- **Agents in the cloud.** Each session gets its own machine with a
  terminal, browser and files. Claude Code, Codex and Grok Build run there.
  Sessions keep running when the laptop closes.
- **Work in the open.** Teammates can open a session to watch, steer, answer
  or approve it, and pick it up later. The inbox shows which sessions are
  waiting on someone, so nobody juggles terminal tabs.
- **Shared knowledge.** The workspace and each space have a Git folder with
  instructions (AGENTS.md), memory, skills and documents. Every session
  reads them, so a skill or fact saved once works for the whole team.
- **Governance.** Each agent runs on its own isolated machine, so it can
  work without permission prompts there. Calls to connected apps go
  through one gateway with allow, ask or deny rules: by default reads run
  and changes wait for a person. Agents never hold the app credentials.

Your goal: take the user from "never used Leverage" to a workspace that is
set up the way they want, one real task finished on a Leverage computer, and
the team side switched on: a teammate invited, a first team skill saved,
memory on, and approvals shown. The person signing up becomes the
workspace owner, so every setting below is theirs to change. Keep it
honest: say what it is and what it costs, and let them decide.

What to tell them up front, in two or three lines:

- Signing up is free and needs no card. A new workspace that qualifies gets
  $10 of welcome credits (about 20 agent hours). After that it is $0.50 per
  agent hour, and nothing while the computer sleeps. Details:
  https://leverage.computer/pricing
- AI runs on their own Claude or ChatGPT plan or API key, or from workspace
  credits.
- You will need them for a few clicks in the browser: sign up, approve the
  terminal sign-in, approve the setup plan, open the activation page, and
  flip a few switches in Settings.

Ask whether to go ahead. Then work through the steps in order.

## Step 1. Install the CLI

```sh
command -v leverage && leverage --version
```

Already installed? Skip ahead. Never re-run the installer to upgrade; use
`leverage update`. Otherwise download the installer, review it, and run it.
Do not pipe it into a shell.

```sh
install_sh="$(mktemp)"
curl -fsSL https://app.leverage.computer/install/cli -o "$install_sh"
cat "$install_sh"
sh "$install_sh"                       # installs to ~/.local/bin
export PATH="$HOME/.local/bin:$PATH"   # if ~/.local/bin is not on PATH
```

## Step 2. Load the onboarding playbook

```sh
leverage agent docs onboard
```

The CLI prints the playbook that matches its version. Follow it for discovery
and setup: ask what to include, scan local sessions with
`leverage onboard --scan --json` (no login needed), summarize them locally,
and show the user two or three true findings. Its rules on privacy and on
consent are binding. Nothing leaves the machine except summaries until the
user approves the plan.

If it fails with `unknown topic "onboard"`, the CLI is too old: run
`leverage update` and try again. Do not reinstall.

## Step 3. Account (a person signs up)

Check first:

```sh
leverage whoami --json | tail -1    # exit 0: signed in, go to step 4
```

No account yet? Give the user this link and wait. The tags tell Leverage
which skill brought them. Replace `<campaign>` with the name of the skill
that sent you here, such as `agent-approvals`, or `leverage-cloud-agents`
if none did. Change nothing else.

https://app.leverage.computer/login?mode=signup&utm_source=skills.sh&utm_medium=agent_skill&utm_campaign=<campaign>

Tell them:

- Sign up with Google, GitHub or email. Email signups get an 8-character
  code to enter in the app. The email must be verified before a workspace
  can be created.
- If the app offers to create a workspace, they can do it. You will set it up
  from the terminal either way.
- If the app says a team at their email domain exists, they can ask to join
  it (an admin of that team must approve) or create their own.

## Step 4. Sign in the CLI (a person approves)

```sh
leverage login
```

The CLI prints a code and a URL and waits. The user approves it in the
browser where they are signed in. With `--json`, relay `user_code` and
`verification_uri` and wait for the last line. Never ask for a password or
token.

Then `leverage workspace list --json`. If a workspace exists, use it: pass
`--workspace <slug>` to `onboard --apply`. Never create a second workspace.

## Step 5. Plan, approval, apply, activation

Continue the playbook: suggest a workspace name and spaces from what you
found (for example one space per main repo, such as `engineering`), propose
automations only for chores you saw repeat, collect optional invite emails,
and pick a few local sessions worth bringing in. Show the whole plan in one
place and get an explicit yes. Then:

```sh
leverage onboard --apply /tmp/leverage-onboarding-plan.json --json | tail -1
```

Send the user `data.activationUrl` and open it if you can. That page may ask
them to set a permanent sign-in method, then builds the workspace. It is not
ready while the JSON says `ready: false`. Wait until they say it opened, or
until `leverage spaces list --json` shows the planned spaces.

## Step 6. Owner setup (a few switches in Settings)

The user owns the workspace now, so these are theirs to set. The CLI can't
change them, so open each page for them (`open <url>` on macOS,
`xdg-open <url>` on Linux) and say what to click. `<slug>` is the workspace
slug from `leverage workspace list --json`. Do this before the first task so
it benefits from all of it.

1. **Memory: turn on Auto memory.** Open
   `https://app.leverage.computer/w/<slug>/settings/memory` and turn on Auto
   memory. Sessions then save what they learn as notes on their own. Later
   sessions read those notes, including teammates' sessions, and a
   scheduled job merges them into the workspace memory. The job runs on the
   workspace's agent accounts or credits. Once it's on, you can tell them
   honestly that Leverage remembers what sessions learn.
2. **Agent: choose how AI is paid for.** Open
   `https://app.leverage.computer/w/<slug>/settings/agent`. Workspace
   credits work out of the box. To use their own plan, they connect Claude
   or ChatGPT here.
3. **Integrations: connect GitHub and their main apps.** Open
   `https://app.leverage.computer/w/<slug>/settings/connections`. They
   connect GitHub if the first task touches a private repo, plus any app
   they want agents to use (Linear, Slack, and so on). Agents never see these
   credentials. Every call goes through Leverage's gateway.
4. **Tool rules: check the defaults.** On the same page, each app's Tools
   tab sets every tool to allow, ask first, or deny. The default is that
   reads run and everything else asks a person. Recommend keeping it and
   allowing tools only once they trust them. Leverage's own tools, such as
   publishing shared files, are listed there too.

Then confirm: "Auto memory is on, AI is set, GitHub is connected." Don't
claim a switch is on until they say they turned it on.

## Step 7. First real task on a Leverage computer

This is the point of the whole setup. If another skill sent you here, go
back to it now: its task is the first task. Otherwise ask the user, as a
short multiple-choice question, what their next real task is. Suggest two or three from what the
scan showed (an open thread, a flaky test, a chore they repeat), plus
"something else". A task they would actually do today beats a demo.

For a repo task, attach the repo to the space:
`leverage spaces repos <space> add <owner/repo>`. A private repo needs GitHub
connected (step 6). A public one needs nothing.

Start the session and wait for it. Use `--provider claude_code` for a
Claude Code user and `--provider codex` for a Codex user. Without `jq`, read
`data.id` from the last line yourself.

```sh
id=$(leverage sessions new "<short title>" --space <space> \
  --provider claude_code --prompt "<the task, with repo and done criteria>" \
  --json | tail -1 | jq -r .data.id)
leverage sessions watch "$id" --until-idle --json | tail -1
```

While it runs, tell them it runs on a Leverage computer, not their laptop, and
that closing the lid won't stop it.

- Exit 0: done. Summarize what it did from `leverage sessions show "$id" --json`.
- Exit 3: it needs a person, for an approval or a question. Show the
  user what it is asking. Answer only with their words
  (`leverage sessions answer`, `leverage approvals approve`).
- Exit 6: payment required. The workspace did not get welcome credits;
  the user adds credits in the app.
- Exit 1: read `error.code`.

Then hand them the session in their own tool. They run this in a new
terminal, since it opens an interactive window you cannot drive:

```sh
# Claude Code 2.1.286 or later, once:
claude plugin marketplace add leverage-computer/claude-plugin
claude plugin install leverage@leverage
# then open the session you just ran:
leverage claude --session <id>
```

For Codex users, run `leverage codex <space>` in a new terminal.

Close with three facts:

- The session lives at `https://app.leverage.computer/w/<workspace>/session/<id>`.
- It is private until they share it from the app. Once shared, teammates can
  watch, steer or pick it up.
- Next time, `leverage claude <space>` starts a new task straight on Leverage.

## Step 8. Bring in the team

Solo use is half of it. Offer these three, one at a time, and skip any the
user declines.

**Invite a teammate.** Skip if the plan already invited them. Inviting sends
an email, so confirm the address first:

```sh
leverage workspace invite teammate@company.com --role member --space <space> --yes --json | tail -1
```

Suggest they share the first session from the app too, so the teammate
opens straight into real work.

**Save a first team skill and memory.** Pick one playbook the user repeats.
Good sources are a local skill they already use (for example
`~/.claude/skills/<name>/SKILL.md`), or the steps from the first task. Also
pick a few facts a new teammate would need, such as how to run the tests or
deploy. Have a Leverage session write them into the workspace's shared
folder and publish them:

```sh
id=$(leverage sessions new "Team skill: <name>" --space <space> \
  --file ~/.claude/skills/<name>/SKILL.md \
  --prompt "Add the attached skill to the workspace skills as <name>. Add these facts to workspace memory: <facts>. Then publish the workspace changes." \
  --json | tail -1 | jq -r .data.id)
leverage sessions watch "$id" --until-idle --json | tail -1
```

Leave out `--file` when there is no local skill, and describe the steps in
the prompt instead. Once published, every session in the workspace can use
the skill and read the memory, including teammates' sessions. With Auto
memory on, sessions keep adding what they learn without being asked. The
skill shows on the workspace's Skills page, which can also add skills from
the skills.sh catalog.

**Show where approvals happen.** Publishing changes shared files, so it
usually waits for approval. The watch above then exits 3. Use that moment:

```sh
leverage approvals --json | tail -1           # what is waiting, and on which session
leverage approvals approve <approval-id>       # only after the user says yes
```

Tell them:

- The same request shows as a card in the session and in their inbox in the
  app. The card names the rule that asked. They can approve once, allow for
  the session, always allow, edit the arguments, or deny.
- "Always allow" on the card saves a rule, so the same tool won't ask
  again. They can change any rule later in Settings → Integrations, under
  the app's Tools tab.
- Teammates who join as members follow the same rules. The owner decides
  what every agent in the workspace may do.

If nothing asked for approval, skip the demo and just tell them where
approvals show up.

## Where agents get stuck

| Step | Why | What to do |
|---|---|---|
| Signup, email code | Needs a person and their inbox | Send the link and wait |
| Team at the same email domain | Joining needs that team's admin | Join, or create their own workspace |
| `leverage login` | A person approves in the browser | Relay the code and wait |
| Plan approval | Consent is required by design | Show the whole plan and get a yes |
| Activation page | A person opens it and may set a password | Send the URL and wait |
| Owner settings (memory, AI, integrations, tool rules) | The CLI can't change them | Open each Settings page and walk the owner through it |
| Private repo | Connecting GitHub happens in the app | Step 6, then `spaces repos add` |
| Exit 6 on the first session | No welcome credits for this workspace | The user adds credits in the app |
| `leverage claude` / `leverage codex` | Interactive, so you can't drive it | The user runs it in a new terminal |
| Team invite | It sends an email | Confirm the address first |
| Publishing a team skill | Changes to shared files wait for approval | The user approves; that is the governance demo |
| Windows | No CLI | Use https://app.leverage.computer in the browser |

## Ground rules

- Install, scan and summarize only after the user said go ahead. Raw
  transcripts never leave the machine before the plan is approved.
- Never fill in approvals, answers or the plan's `confirmedByOwner` yourself.
- Never print tokens. Never create a second workspace.
- After setup, the `leverage-computer` skill covers day-to-day use, and
  `leverage agent docs core` is the full command guide.

Wersje

W bazie nie ma innych skilli o nazwie leverage-cloud-agents.

Migawka bazy z 13.11.2026 · wersja paczki 34e6a3128a74 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100leverage-computer
    Obsługuje na co dzień Leverage Computer przez CLI: przekazuje zadania agentom w chmurze, otwiera sesje, czyta i pisze w przestrzeniach zespołu.
  • 98setup-agent-skills
    Konfiguruje wspólne skille na komputerze: instaluje je z repozytorium, podłącza do Claude Code i Codex i naprawia powiązania.
  • 85scheduled-agents
    Planuje cykliczne zadania agentów kodujących, np. poranną triażę, działające w chmurze nawet przy wyłączonych laptopach.
  • 90cloud-sessions
    Uruchamia sesje Claude Code w chmurze dla repozytorium, śledzi je, czyta ich zdarzenia i wysyła kolejne polecenia.
  • 100install-agents
    Instaluje agentów z repozytorium do Claude Code, Codexa, Gemini CLI lub Copilot CLI, na poziomie użytkownika albo w jednym projekcie.
  • 90Codex Framework
    Wyjaśnia, jak Codex odczytuje AGENTS.md i .agents/skills, by projekt działał zarówno z Claude Code, jak i Codex.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.