gpu4agents 0.5.0__tar.gz → 0.6.0__tar.gz

{gpu4agents-0.5.0 → gpu4agents-0.6.0}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses [Semantic Versioning](https://semver.org/).
 
+## [0.6.0] - 2026-11-02
+
+### Added
+- **Agents install it themselves.** Paste one line into Claude Code, Codex, Gemini CLI or Cursor; the agent follows [`INSTALL.md`](INSTALL.md) (served at `gpu4agents.jambu.ai/install.md`) and sets everything up, without renting anything.
+- `install.sh`: needs only `curl`. Installs uv if missing and `gpu4agents` with a Python uv downloads when needed, removes an old `jambu-gpu` tool, and runs `gpu agent install` for the runtimes it finds (`--agent` to pick one).
+- `gpu login`: the user types the Vast.ai key into a hidden prompt; it is checked against the API, then saved in `~/.gpu/credentials` (mode 600). `--check` reports whether a working key is found and where; `--stdin` reads it from a pipe.
+- `gpu agent install -t codex` (skill in `.agents/skills/`, MCP server in `~/.codex/config.toml`), `-t gemini` (skill in `.agents/skills/`, MCP server in `.gemini/settings.json`) and `-t auto` (every runtime found).
+- The skill is published at `skills/gpu4agents/SKILL.md`, so `npx skills add jambuai/gpu4agents` installs it, and it now covers installation, connecting the account, monitoring (`status`, `logs`, `events`, `ls`, `sweep`) and the exit codes.
+
+### Changed
+- The skill is named `gpu4agents` (it was `gpu`). `gpu agent install` replaces the old `gpu` skill folder it wrote before; a folder of the same name from someone else is left alone.
+- Cursor now gets the skill in `.agents/skills/` instead of `.claude/skills/`.
+
 ## [0.5.0] - 2026-11-02
 
 ### Changed
@@ -52,6 +65,7 @@ All notable changes to this project. The format follows [Keep a Changelog](https
 - A per-instance endpoint key; `gpu --json setup` / `gpu env` return `base_url`, `api_key` and `model`.
 - [docs/INTEGRATION.md](docs/INTEGRATION.md) and a one-file TypeScript client.
 
+[0.6.0]: https://github.com/jambuai/gpu4agents/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/jambuai/gpu4agents/compare/v0.4.1...v0.5.0
 [0.4.1]: https://github.com/jambuai/gpu4agents/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/jambuai/gpu4agents/compare/v0.3.1...v0.4.0

gpu4agents-0.6.0/INSTALL.md

@@ -0,0 +1,53 @@
+# Install GPU for Agents (instructions for the agent)
+
+You are a coding agent (Claude Code, Codex, Gemini CLI, Cursor, or another) and the user asked you to set up **GPU for Agents**: a `gpu` command, a skill and MCP tools that let you rent a cloud GPU, serve a model and run experiments, while a watchdog on the machine shuts it down when idle so the user pays only while it works.
+
+Follow these steps in order. Run the commands yourself; tell the user briefly what each step did.
+
+## 1. Install the `gpu` command and give it to this agent
+
+Pick the name of the runtime you are running in: `claude` (Claude Code), `codex` (Codex), `gemini` (Gemini CLI) or `cursor` (Cursor). If you are none of these, use `auto`.
+
+```bash
+curl -fsSL https://gpu4agents.jambu.ai/install.sh | sh -s -- --agent <runtime>
+```
+
+If that address does not resolve, use the copy in the repository:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/jambuai/gpu4agents/main/install.sh | sh -s -- --agent <runtime>
+```
+
+The script needs only `curl` (Linux or macOS; on Windows, run it inside WSL). It installs [uv](https://docs.astral.sh/uv/) if missing, uses it to install the `gpu4agents` package with a Python it downloads by itself, and then installs the skill and registers the `gpu` MCP server for your runtime. It does not ask for or read any key.
+
+Check: `~/.local/bin/gpu --version` prints 0.6.0 or later. Use `~/.local/bin/gpu` for the rest of this session if plain `gpu` is not found.
+
+## 2. Connect the user's GPU account
+
+Run `gpu login --check`.
+
+- Exit code 0: the account is connected. Go to step 3.
+- Exit code 5: no working key yet. Tell the user, in these words or close:
+
+  > Create an API key at https://cloud.vast.ai/manage-keys/ and add a few dollars of credit. Then open your own terminal, run `gpu login`, and paste the key into the hidden prompt.
+
+  Wait until the user says it is done, then run `gpu login --check` again.
+
+Never ask the user to paste the key into this conversation, never read `~/.gpu/credentials` or `.env` files, and never print the key.
+
+## 3. Learn how to use it
+
+Run `gpu agent skill` and read the output: it is the skill you just installed, with the rules (ask before renting, wait out a slow setup, clean up), the commands, monitoring and error codes. Follow it from now on in this session.
+
+The MCP tools (`gpu_setup`, `gpu_status`, ...) appear after the user restarts the agent. Until then, the CLI does everything: `gpu --json <command>`.
+
+## 4. Tell the user it is ready
+
+Summarize in a few lines:
+
+- what was installed (the `gpu` command, the skill, the MCP server for this runtime);
+- whether the account is connected, or what they still need to do (`gpu login`);
+- that they should restart the agent to get the tools;
+- an example request: "Compare Qwen 7B and Llama 8B on 50 prompts", and that you will show the price and ask before renting anything.
+
+Do not rent a GPU as part of the installation.

{gpu4agents-0.5.0 → gpu4agents-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gpu4agents
-Version: 0.5.0
+Version: 0.6.0
 Summary: GPU for Agents: your coding agent rents the GPU it needs, on its own. You pay only while it works.
 Project-URL: Homepage, https://gpu4agents.jambu.ai
 Project-URL: Documentation, https://github.com/jambuai/gpu4agents/tree/main/docs
@@ -67,22 +67,35 @@ Description-Content-Type: text/markdown
 
 Ask Claude Code, Cursor or any MCP client to "compare Qwen 7B and Llama 8B on these 50 prompts". The agent finds a GPU under your budget, serves the model behind an OpenAI-compatible API with vLLM, and runs the experiment. A watchdog runs on the machine itself, so when nothing uses it for `idle_timeout` (15 minutes by default) it shuts down, even if the agent forgot, the chat closed or your laptop is asleep.
 
-- **Self-service GPUs for agents.** A skill and local MCP tools (`gpu_offers`, `gpu_setup`, `gpu_run`, `gpu_status`, `gpu_destroy`, ...) give the agent the whole lifecycle. The skill tells it to show you the price and ask before renting.
+- **Self-service GPUs for agents.** Claude Code, Codex, Gemini CLI and Cursor install it themselves from one pasted line. A skill and local MCP tools (`gpu_offers`, `gpu_setup`, `gpu_run`, `gpu_status`, `gpu_destroy`, ...) give the agent the whole lifecycle. The skill tells it to show you the price and ask before renting.
 - **Billing that ends when the work does.** Idle timeout, maximum lifetime, hourly and session budgets, and a sweep that cleans up anything left behind.
 - **Any app, any language.** `gpu --json setup` returns `base_url`, `api_key` and `model` for any OpenAI SDK.
 
 Vast.ai is the first provider; another provider is a new adapter, and the lifecycle rule stays the same.
 
-## Quickstart: give your agent a GPU
+## Quickstart: let your agent install it
+
+Paste this into Claude Code, Codex, Gemini CLI or Cursor (say which one you use):
+
+```text
+Set up GPU for Agents for me. I'm using Claude Code. Fetch https://gpu4agents.jambu.ai/install.md with curl and follow its steps.
+```
+
+The agent installs the `gpu` command (with [uv](https://docs.astral.sh/uv/), which brings its own Python), the `gpu4agents` skill and the `gpu` MCP tools. Then you connect your GPU account in your own terminal, so the agent never sees the key:
 
 ```bash
-pipx install gpu4agents            # or: uv tool install gpu4agents
-cd your-project
-echo "VAST_API_KEY=..." >> .env    # or ~/.gpu/credentials; never in jambu.yaml
-gpu agent install                  # Claude Code; -t cursor, -t desktop, --global
+gpu login        # paste your Vast.ai key (https://cloud.vast.ai/manage-keys/) into the hidden prompt
 ```
 
-Then ask the agent for an experiment. See [Letting a coding agent rent GPUs](docs/AGENTS.md).
+Restart the agent and ask for an experiment. It shows the price and asks before renting anything. See [Letting a coding agent rent GPUs](docs/AGENTS.md).
+
+Prefer a terminal? These do the same:
+
+```bash
+curl -fsSL https://gpu4agents.jambu.ai/install.sh | sh          # uv + Python + gpu, then every agent it finds
+npx skills add jambuai/gpu4agents                              # just the skill; it installs gpu on first use
+uv tool install gpu4agents && gpu agent install -t codex --global   # by hand: claude | codex | gemini | cursor | auto
+```
 
 ## Quickstart: from a shell or an app
 
@@ -116,11 +129,11 @@ gpu_runtime:
 
 A full example is [`jambu.example.yaml`](jambu.example.yaml). As a last line of defense, `gpu ls` shows every machine billing in the account and `gpu sweep --install-timer` guards every project on the machine and cleans up orphans. See [Keeping the account clean](docs/USAGE.md#keeping-the-account-clean).
 
-The API key is read from the environment, a project `.env`, or `~/.gpu/credentials`. It never goes in the manifest, and the agent never sees it.
+`gpu login` saves the API key in `~/.gpu/credentials` (mode 600) after checking it; the environment and a project `.env` work too. It never goes in the manifest, and the agent never sees it.
 
 ## Docs
 
-- [Letting a coding agent rent GPUs (Claude Code, Cursor, Claude Desktop)](docs/AGENTS.md)
+- [Letting a coding agent rent GPUs (Claude Code, Codex, Gemini CLI, Cursor, Claude Desktop)](docs/AGENTS.md)
 - [Integrating into an application (any language)](docs/INTEGRATION.md)
 - [Commands, workloads, and agents](docs/USAGE.md)
 - [Every config field](docs/CONFIG.md)

{gpu4agents-0.5.0 → gpu4agents-0.6.0}/README.md

@@ -26,22 +26,35 @@
 
 Ask Claude Code, Cursor or any MCP client to "compare Qwen 7B and Llama 8B on these 50 prompts". The agent finds a GPU under your budget, serves the model behind an OpenAI-compatible API with vLLM, and runs the experiment. A watchdog runs on the machine itself, so when nothing uses it for `idle_timeout` (15 minutes by default) it shuts down, even if the agent forgot, the chat closed or your laptop is asleep.
 
-- **Self-service GPUs for agents.** A skill and local MCP tools (`gpu_offers`, `gpu_setup`, `gpu_run`, `gpu_status`, `gpu_destroy`, ...) give the agent the whole lifecycle. The skill tells it to show you the price and ask before renting.
+- **Self-service GPUs for agents.** Claude Code, Codex, Gemini CLI and Cursor install it themselves from one pasted line. A skill and local MCP tools (`gpu_offers`, `gpu_setup`, `gpu_run`, `gpu_status`, `gpu_destroy`, ...) give the agent the whole lifecycle. The skill tells it to show you the price and ask before renting.
 - **Billing that ends when the work does.** Idle timeout, maximum lifetime, hourly and session budgets, and a sweep that cleans up anything left behind.
 - **Any app, any language.** `gpu --json setup` returns `base_url`, `api_key` and `model` for any OpenAI SDK.
 
 Vast.ai is the first provider; another provider is a new adapter, and the lifecycle rule stays the same.
 
-## Quickstart: give your agent a GPU
+## Quickstart: let your agent install it
+
+Paste this into Claude Code, Codex, Gemini CLI or Cursor (say which one you use):
+
+```text
+Set up GPU for Agents for me. I'm using Claude Code. Fetch https://gpu4agents.jambu.ai/install.md with curl and follow its steps.
+```
+
+The agent installs the `gpu` command (with [uv](https://docs.astral.sh/uv/), which brings its own Python), the `gpu4agents` skill and the `gpu` MCP tools. Then you connect your GPU account in your own terminal, so the agent never sees the key:
 
 ```bash
-pipx install gpu4agents            # or: uv tool install gpu4agents
-cd your-project
-echo "VAST_API_KEY=..." >> .env    # or ~/.gpu/credentials; never in jambu.yaml
-gpu agent install                  # Claude Code; -t cursor, -t desktop, --global
+gpu login        # paste your Vast.ai key (https://cloud.vast.ai/manage-keys/) into the hidden prompt
 ```
 
-Then ask the agent for an experiment. See [Letting a coding agent rent GPUs](docs/AGENTS.md).
+Restart the agent and ask for an experiment. It shows the price and asks before renting anything. See [Letting a coding agent rent GPUs](docs/AGENTS.md).
+
+Prefer a terminal? These do the same:
+
+```bash
+curl -fsSL https://gpu4agents.jambu.ai/install.sh | sh          # uv + Python + gpu, then every agent it finds
+npx skills add jambuai/gpu4agents                              # just the skill; it installs gpu on first use
+uv tool install gpu4agents && gpu agent install -t codex --global   # by hand: claude | codex | gemini | cursor | auto
+```
 
 ## Quickstart: from a shell or an app
 
@@ -75,11 +88,11 @@ gpu_runtime:
 
 A full example is [`jambu.example.yaml`](jambu.example.yaml). As a last line of defense, `gpu ls` shows every machine billing in the account and `gpu sweep --install-timer` guards every project on the machine and cleans up orphans. See [Keeping the account clean](docs/USAGE.md#keeping-the-account-clean).
 
-The API key is read from the environment, a project `.env`, or `~/.gpu/credentials`. It never goes in the manifest, and the agent never sees it.
+`gpu login` saves the API key in `~/.gpu/credentials` (mode 600) after checking it; the environment and a project `.env` work too. It never goes in the manifest, and the agent never sees it.
 
 ## Docs
 
-- [Letting a coding agent rent GPUs (Claude Code, Cursor, Claude Desktop)](docs/AGENTS.md)
+- [Letting a coding agent rent GPUs (Claude Code, Codex, Gemini CLI, Cursor, Claude Desktop)](docs/AGENTS.md)
 - [Integrating into an application (any language)](docs/INTEGRATION.md)
 - [Commands, workloads, and agents](docs/USAGE.md)
 - [Every config field](docs/CONFIG.md)

{gpu4agents-0.5.0 → gpu4agents-0.6.0}/docs/ACCEPTANCE.md

@@ -61,6 +61,8 @@ It found two more bugs, both fixed and tested: Vast reports a stopping instance
 
 On 2026-10-25 a headless Claude Code with no prior context (`claude -p`) was given a fresh directory holding only `gpu agent install`'s skill and `.mcp.json`, plus `VAST_API_KEY` in `.env`. It was asked in one sentence to test Qwen2.5-0.5B on a rented GPU, ask it the capital of Brazil, report time and cost, and destroy the machine. It loaded the `gpu` skill by itself and called `gpu_init` (with the cap and VRAM from the request), `gpu_validate`, `gpu_offers`, then `gpu_setup` until ready, `curl` for the question, `gpu_status`, `gpu_destroy` and `gpu_ls`. The model answered "Brasília", the account was empty at the end, and the agent reported setup time and cost correctly, noting that `session_cost_usd` leaves out the replaced host.
 
+On 2026-11-02 the self-install was checked the same way. In an empty home directory with no `uv`, `gpu` or Python tool on `PATH`, a headless Claude Code got one sentence: "Set up GPU for Agents for me. I'm using Claude Code. Fetch …/install.md with curl and follow its steps." It ran `install.sh --agent claude`, which put `gpu` 0.6.0 in `~/.local/bin`, the skill in `~/.claude/skills/gpu4agents/` and the `gpu` server in the user MCP config. `gpu login --check` exited 5, and the agent told the user to create a key and run `gpu login` in their own terminal, without asking for the key. It read the skill with `gpu agent skill` and rented nothing. Separately, `install.sh` run with `GPU4AGENTS_PYTHON=3.13` on a machine without Python 3.13 had uv download CPython 3.13 and install the tool on it.
+
 | What was checked | What happened |
 | --- | --- |
 | Setup longer than any tool timeout | `gpu_setup` returned `running` every 300 s for 42 minutes and re-attached to the same background job each time: one machine at a time, never a second setup. |

{gpu4agents-0.5.0 → gpu4agents-0.6.0}/docs/AGENTS.md

@@ -1,31 +1,57 @@
 # Letting a coding agent rent GPUs
 
-`gpu` ships a skill and a local MCP server, so Claude Code, Cursor or Claude Desktop can rent a GPU, serve a model, run an experiment against it and shut it down, from a request like "compare Qwen 7B and Llama 8B on these 50 prompts".
+`gpu` ships a skill and a local MCP server, so Claude Code, Codex, Gemini CLI, Cursor or Claude Desktop can rent a GPU, serve a model, run an experiment against it and shut it down, from a request like "compare Qwen 7B and Llama 8B on these 50 prompts".
 
 The watchdog on the machine is what makes this safe to hand to an agent: a machine the agent forgets, or a conversation that ends mid-experiment, stops by itself after `lifecycle.idle_timeout`.
 
-## Install
+## Install: let the agent do it
+
+Paste into the agent, naming it:
+
+```text
+Set up GPU for Agents for me. I'm using Codex. Fetch https://gpu4agents.jambu.ai/install.md with curl and follow its steps.
+```
+
+[`INSTALL.md`](../INSTALL.md) (served at `/install.md`) tells the agent to run [`install.sh`](../install.sh) with `--agent <runtime>`, check the account with `gpu login --check`, send the user to `gpu login` if there is no key, read the skill with `gpu agent skill`, and stop there: nothing is rented during installation.
+
+`install.sh` needs only `curl` on Linux or macOS (Windows: WSL). It installs [uv](https://docs.astral.sh/uv/) if missing and runs `uv tool install --upgrade --python 3.12 gpu4agents`, so uv downloads a Python when the machine has no suitable one. It removes an old `jambu-gpu` tool, then runs `gpu agent install -t <runtime> --global` (`auto` by default: every runtime it finds). Options: `--agent claude|codex|gemini|cursor|auto|none`, `--no-modify-path`; `GPU4AGENTS_SPEC` installs a pinned version or a wheel.
+
+With the [skills](https://skills.sh) CLI, `npx skills add jambuai/gpu4agents` installs only the skill (from [`skills/gpu4agents/`](../skills/gpu4agents/SKILL.md)); its first section installs the `gpu` command when it is missing.
+
+## Connect the account: `gpu login`
+
+The user, in their own terminal:
+
+```bash
+gpu login            # hidden prompt; checks the key against Vast.ai, then saves it
+gpu login --check    # exit 0 and where the key was found, or exit 5
+echo "$KEY" | gpu login --stdin
+```
+
+The key goes to `~/.gpu/credentials` (mode 600, directory 700); other lines in the file are kept. A key in the environment or a project `.env` still works and wins over the file. The skill tells the agent never to ask for the key in chat, read those files, or print it.
+
+## Install by hand
 
 ```bash
-pipx install gpu4agents            # or: uv tool install gpu4agents
-cd your-project
-echo "VAST_API_KEY=..." >> .env   # or ~/.gpu/credentials; never in jambu.yaml
-gpu agent install                 # Claude Code
-gpu agent install -t cursor       # Cursor
-gpu agent install -t desktop      # Claude Desktop
+uv tool install --python 3.12 gpu4agents    # or: pipx install gpu4agents
+gpu agent install -t claude                 # this project; add --global for every project
+gpu agent install -t auto --global          # every runtime on this machine
 ```
 
 | Target | Skill | MCP server |
 | --- | --- | --- |
-| `claude` (default) | `.claude/skills/gpu/SKILL.md` | `.mcp.json` (Claude Code asks once to approve it) |
-| `cursor` | the same `.claude/skills/gpu/` (Cursor reads Claude's skill directories) | `.cursor/mcp.json`, with `--project ${workspaceFolder}` |
+| `claude` | `.claude/skills/gpu4agents/SKILL.md` | `.mcp.json` (Claude Code asks once to approve it); `--global`: `claude mcp add --scope user` |
+| `codex` | `.agents/skills/gpu4agents/SKILL.md` | `[mcp_servers.gpu]` in `$CODEX_HOME/config.toml` (`~/.codex`), always user-wide |
+| `gemini` | `.agents/skills/gpu4agents/SKILL.md` | `mcpServers.gpu` in `.gemini/settings.json` |
+| `cursor` | `.agents/skills/gpu4agents/SKILL.md` | `.cursor/mcp.json`, with `--project ${workspaceFolder}` |
 | `desktop` | `~/.gpu/gpu-skill.zip`, to upload under Settings > Capabilities > Skills | `claude_desktop_config.json`, pinned to this project |
+| `auto` | every runtime found: its command on `PATH` or its config directory | |
 
-`--global` installs for every project of the user instead: the skill in `~/.claude/skills/gpu/`, the MCP server through `claude mcp add --scope user` and in `~/.cursor/mcp.json`. Existing config files are merged; only the `gpu` entry is written. Re-running is safe.
+`.agents/skills/` is the shared directory Codex, Gemini CLI and Cursor all read. `--global` puts skills and settings under the home directory instead of the project. Existing config files are merged; only the `gpu` entry is written, and a skill installed by an older version under the name `gpu` is replaced. Re-running is safe. Restart the agent afterwards so it loads the skill and the tools.
 
-Claude Desktop and Cursor do not get your shell's environment. Keep `VAST_API_KEY` in the project `.env` or `~/.gpu/credentials`, not only in an `export`.
+Claude Desktop and Cursor do not get your shell's environment. Keep `VAST_API_KEY` in `~/.gpu/credentials` (`gpu login`) or the project `.env`, not only in an `export`.
 
-Another agent that reads `SKILL.md` files: `gpu agent skill > path/to/skills/gpu/SKILL.md`. Any MCP client: run `gpu mcp --project /path/to/project` over stdio.
+Another agent that reads `SKILL.md` files: `gpu agent skill > path/to/skills/gpu4agents/SKILL.md`. Any MCP client: run `gpu mcp --project /path/to/project` over stdio.
 
 ## The MCP tools
 

{gpu4agents-0.5.0 → gpu4agents-0.6.0}/gpu4agents/__init__.py

@@ -1,5 +1,5 @@
 """GPU for Agents: GPUs your agent rents on its own, billed only while they work."""
 
-__version__ = "0.5.0"
+__version__ = "0.6.0"
 
 __all__ = ["__version__"]

{gpu4agents-0.5.0 → gpu4agents-0.6.0}/gpu4agents/agent/install.py

@@ -1,16 +1,23 @@
 """`gpu agent install`: put the skill and the MCP server where agents look for them.
 
-One skill copy, in ``.claude/skills/gpu/`` (or ``~/.claude/skills/gpu/``),
-serves both Claude Code and Cursor, which also reads Claude's skill
-directories. The MCP server is registered per client:
+Skills follow the open Agent Skills layout, one folder with a SKILL.md:
+
+- claude:              ``.claude/skills/gpu4agents/`` (Claude Code; Cursor reads it too)
+- codex, gemini, cursor: ``.agents/skills/gpu4agents/``, the shared directory
+  Codex, Gemini CLI and Cursor all read
+
+Each is per project, or under the home directory with --global. The MCP server
+is registered per client:
 
 - claude:  ``.mcp.json`` in the project; with --global, ``claude mcp add -s user``
+- codex:   ``[mcp_servers.gpu]`` in ``$CODEX_HOME/config.toml`` (``~/.codex``)
+- gemini:  ``mcpServers.gpu`` in ``.gemini/settings.json``, or ``~/.gemini/settings.json``
 - cursor:  ``.cursor/mcp.json`` in the project, or ``~/.cursor/mcp.json``
 - desktop: Claude Desktop's ``claude_desktop_config.json``, pinned to this
   project, plus a zip of the skill to upload in Settings
 
-Existing config files are merged, never replaced: only the ``gpu`` server
-entry is written.
+``auto`` picks every runtime found on this machine. Existing config files are
+merged, never replaced: only the ``gpu`` server entry is written.
 """
 
 from __future__ import annotations
@@ -18,6 +25,7 @@ from __future__ import annotations
 import json
 import os
 import platform
+import re
 import shutil
 import subprocess
 import sys
@@ -29,8 +37,10 @@ from ..core.errors import ConfigError
 from ..core.paths import gpu_home
 
 SERVER_NAME = "gpu"
-SKILL_NAME = "gpu"
-TARGETS = ("claude", "cursor", "desktop")
+SKILL_NAME = "gpu4agents"
+LEGACY_SKILL_NAME = "gpu"
+TARGETS = ("claude", "codex", "gemini", "cursor", "desktop")
+SHARED_SKILL_TARGETS = ("codex", "gemini", "cursor")
 
 
 def skill_source() -> Path:
@@ -66,6 +76,25 @@ def desktop_config_path() -> Path:
     return (Path(base) if base else Path.home() / ".config") / "Claude" / "claude_desktop_config.json"
 
 
+def codex_home() -> Path:
+    return Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex")
+
+
+def detect_targets() -> list[str]:
+    """Runtimes present on this machine: their command on PATH or their config directory."""
+    home = Path.home()
+    found = []
+    if shutil.which("claude") or (home / ".claude").is_dir():
+        found.append("claude")
+    if shutil.which("codex") or codex_home().is_dir():
+        found.append("codex")
+    if shutil.which("gemini") or (home / ".gemini").is_dir():
+        found.append("gemini")
+    if shutil.which("cursor") or shutil.which("cursor-agent") or (home / ".cursor").is_dir():
+        found.append("cursor")
+    return found
+
+
 def merge_server(path: Path, entry: dict[str, Any]) -> str:
     """Write ``mcpServers.gpu`` into a JSON config. Returns created/updated/unchanged."""
     data: dict[str, Any] = {}
@@ -90,8 +119,60 @@ def merge_server(path: Path, entry: dict[str, Any]) -> str:
     return action
 
 
+_TOML_TABLE = re.compile(r"^\s*\[\[?[^\]]+\]\]?\s*(#.*)?$")
+
+
+def merge_codex_server(path: Path, command: list[str]) -> str:
+    """Write ``[mcp_servers.gpu]`` into Codex's config.toml, keeping everything else.
+
+    Python 3.10 has no TOML parser, and only one table is ours, so the table is
+    replaced as text: from its header to the next table header.
+    """
+    header = f"[mcp_servers.{SERVER_NAME}]"
+    block = [
+        header,
+        f"command = {json.dumps(command[0])}",
+        f"args = {json.dumps([*command[1:], 'mcp'])}",
+    ]
+    lines = path.read_text().splitlines() if path.is_file() else []
+    start = next((i for i, line in enumerate(lines) if line.strip() == header), None)
+    if start is None:
+        while lines and not lines[-1].strip():
+            lines.pop()
+        new = lines + ([""] if lines else []) + block
+        action = "created"
+    else:
+        end = next(
+            (i for i in range(start + 1, len(lines)) if _TOML_TABLE.match(lines[i])),
+            len(lines),
+        )
+        old = [line for line in lines[start:end] if line.strip()]
+        if old == block:
+            return "unchanged"
+        tail = lines[end:]
+        new = lines[:start] + block + ([""] + tail if tail else [])
+        action = "updated"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(new) + "\n")
+    return action
+
+
+def _is_our_legacy_skill(path: Path) -> bool:
+    """The skill shipped before 0.6.0 under the name ``gpu``."""
+    try:
+        text = path.read_text()
+    except OSError:
+        return False
+    return text.startswith(f"---\nname: {LEGACY_SKILL_NAME}\n") and "gpu_setup" in text
+
+
 def write_skill(directory: Path) -> str:
     target = directory / SKILL_NAME / "SKILL.md"
+    legacy = directory / LEGACY_SKILL_NAME / "SKILL.md"
+    if _is_our_legacy_skill(legacy):
+        legacy.unlink()
+        if not any(legacy.parent.iterdir()):
+            legacy.parent.rmdir()
     text = skill_text()
     if target.is_file() and target.read_text() == text:
         return "unchanged"
@@ -109,6 +190,21 @@ def write_skill_zip(path: Path) -> str:
     return "created"
 
 
+def resolve_targets(targets: list[str]) -> list[str]:
+    wanted: list[str] = []
+    for target in targets:
+        expanded = detect_targets() if target == "auto" else [target]
+        for name in expanded:
+            if name not in wanted:
+                wanted.append(name)
+    unknown = [t for t in wanted if t not in TARGETS]
+    if unknown:
+        raise ConfigError(
+            f"unknown target {', '.join(unknown)} (choose from {', '.join(TARGETS)}, or auto)"
+        )
+    return wanted
+
+
 def install(
     targets: list[str],
     project_dir: Path,
@@ -116,16 +212,27 @@ def install(
     run=subprocess.run,
 ) -> dict[str, Any]:
     """Install for each target. ``run`` is a seam for tests (``claude mcp add``)."""
-    unknown = [t for t in targets if t not in TARGETS]
-    if unknown:
-        raise ConfigError(f"unknown target {', '.join(unknown)} (choose from {', '.join(TARGETS)})")
+    targets = resolve_targets(targets)
     project_dir = project_dir.resolve()
+    base = Path.home() if global_scope else project_dir
     done: list[dict[str, Any]] = []
     notes: list[str] = []
+    if not targets:
+        notes.append(
+            "no agent runtime found (Claude Code, Codex, Gemini CLI, Cursor); "
+            "name one with -t claude|codex|gemini|cursor|desktop"
+        )
+
+    if "claude" in targets:
+        skills = base / ".claude" / "skills"
+        done.append({"what": "skill (Claude Code)", "path": str(skills / SKILL_NAME / "SKILL.md"), "action": write_skill(skills)})
 
-    if "claude" in targets or "cursor" in targets:
-        skills = (Path.home() if global_scope else project_dir) / ".claude" / "skills"
-        done.append({"what": "skill (Claude Code, Cursor)", "path": str(skills / SKILL_NAME / "SKILL.md"), "action": write_skill(skills)})
+    shared = [t for t in targets if t in SHARED_SKILL_TARGETS]
+    if shared:
+        skills = base / ".agents" / "skills"
+        names = {"codex": "Codex", "gemini": "Gemini CLI", "cursor": "Cursor"}
+        label = ", ".join(names[t] for t in shared)
+        done.append({"what": f"skill ({label})", "path": str(skills / SKILL_NAME / "SKILL.md"), "action": write_skill(skills)})
 
     if "claude" in targets:
         if global_scope:
@@ -147,6 +254,18 @@ def install(
             done.append({"what": "MCP server (Claude Code)", "path": str(path), "action": merge_server(path, entry)})
             notes.append("Claude Code asks once to approve the project's .mcp.json servers")
 
+    if "codex" in targets:
+        # Codex reads MCP servers from the user config; the server works in
+        # whatever directory Codex runs, so one entry serves every project.
+        path = codex_home() / "config.toml"
+        done.append({"what": "MCP server (Codex)", "path": str(path), "action": merge_codex_server(path, gpu_command(portable=False))})
+
+    if "gemini" in targets:
+        command = gpu_command(portable=not global_scope)
+        entry = {"command": command[0], "args": [*command[1:], "mcp"]}
+        path = base / ".gemini" / "settings.json"
+        done.append({"what": "MCP server (Gemini CLI)", "path": str(path), "action": merge_server(path, entry)})
+
     if "cursor" in targets:
         command = gpu_command(portable=not global_scope)
         entry = {
@@ -154,7 +273,7 @@ def install(
             "command": command[0],
             "args": [*command[1:], "mcp", "--project", "${workspaceFolder}"],
         }
-        path = (Path.home() if global_scope else project_dir) / ".cursor" / "mcp.json"
+        path = base / ".cursor" / "mcp.json"
         done.append({"what": "MCP server (Cursor)", "path": str(path), "action": merge_server(path, entry)})
 
     if "desktop" in targets:
@@ -166,8 +285,10 @@ def install(
         done.append({"what": "skill zip (Claude Desktop)", "path": str(archive), "action": write_skill_zip(archive)})
         notes.append(f"Claude Desktop: restart it, then upload {archive} under Settings > Capabilities > Skills")
         notes.append(
-            "Claude Desktop does not get your shell's environment: keep VAST_API_KEY in the "
-            "project .env or ~/.gpu/credentials"
+            "Claude Desktop does not get your shell's environment: keep VAST_API_KEY in "
+            "~/.gpu/credentials (gpu login) or the project .env"
         )
 
-    return {"installed": done, "notes": notes}
+    if any(t in targets for t in ("claude", "codex", "gemini", "cursor")):
+        notes.append("restart the agent (or start a new session) so it loads the skill and the gpu tools")
+    return {"installed": done, "targets": targets, "notes": notes}