# Create, Edit, Delete reference **Page:** foundation/computers/create-edit-delete/reference [Download Raw Markdown](./foundation/computers/create-edit-delete/reference.md) --- # Create, Edit, Delete reference Lookup tables for [creating, updating and deleting computers](/foundation/computers/create-edit-delete/). Every field and status code is in the [Computers API](/api/computers/). ## Create fields The create request body (`POST /api/v1/projects/{id}/computers`) accepts these fields. The last column says whether an update can change it. | Field | Default | Rule | Update | |---|---|---|---| | `server_id` | Required | Where the computer runs: the `server_id` field (not the rental `id`) from your own inventory, `GET /api/v1/rentals` or its alias `GET /api/v1/servers`. Choose by geography, capacity or price. Not `GET /api/v1/servers/available`: its ids are for renting a server, not for placing a computer | No; use [copy](/foundation/computers/copy-sync/#cross-server-copy) | | `name` | Generated | 3-100 characters: letters, digits, hyphens, underscores. Unique within the project; `"rand"` or no name generates one | Yes | | `hoody_kit` | `true` | `true` installs the [Hoody Kit](#hoody-kit-services) HTTP services; `false` gives a plain Linux computer, for minimal overhead, custom service installations or managing everything over SSH yourself. With an auth token, omission also enables Hoody Kit. If the token lacks `computers.features.hoody_kit`, send `hoody_kit: false` or the request returns `403`. Recommended: `hoody_kit: true`, unless you specifically want a plain computer | No | | `dev_kit` | `true` when `hoody_kit: true` | `true` installs the [developer toolchain](#developer-toolchain); `false` omits it to keep the computer smaller. The editor and agent services come with `hoody_kit`, not with this option | No | | `computer_image` | `debian/13` if omitted or `null` | `debian/13` (Debian 13 Trixie), the base image the platform carries; a name that does not resolve to it returns `400` listing the accepted names. See [Computer Images](/foundation/computers/images/) | No: the OS is permanent ([Change the OS](#change-the-os)) | | `environment_vars` | None | Seen by new processes once applied in the computer ([Update rules](#update-rules)) | Yes: add, modify, remove | | `ssh_public_key` | None: no SSH access until you set one | One per computer ([SSH keys](#ssh-keys)). With an auth token, installing a key also needs the `resources.ssh_keys` permission (`403` without it); a signed-in session needs none | Yes | | `realm_ids` | None | [Realms](#realms) | Yes, except by realm-restricted tokens | | `color` | Random | Hex color shown in the UI, with or without `#` ([Colors](#colors)) | Yes | | `comment` | None | A description | Yes | | `autostart` | `true` | Start when the host machine reboots, so services stay available across server maintenance and restarts. With `false` the computer stays stopped after a host reboot until you start it | Yes ([Update rules](#update-rules)) | | `ai` | `true` | AI features default to `true`. With an auth token lacking `computers.features.ai`, send `ai: false` or the request returns `403` | Yes | | `ramdisk` | `true` | Requests the managed [`/ramdisk`](#ram-disk) mount where available | Yes | | `ramdisk_scope` | `computer` | Only `computer` is accepted for now ([RAM disk](#ram-disk)) | No other value | | `kvm` | `false` | `true` passes `/dev/kvm` through to run full virtual machines, on rented or dedicated servers only ([Virtual Machines](/foundation/servers/virtual-machines/)) | Only with `PUT /api/v1/computers/{id}/kvm`, on a stopped computer | ```json { "comment": "Development environment for Project X", "autostart": true, "ai": true, "ramdisk": true } ``` ## Developer toolchain `dev_kit: true` installs a developer toolchain inside the computer. Check for a tool with `command -v` before relying on it. | Rule | Tools | |---|---| | Node.js | A fresh image gets 26.13.1. An image that already has a Node.js 26 release keeps it; if 26.13.1 is not available, the newest 26 release is installed | | Latest release at install time | Go, Rust, Bun, Nix, pkgx, GitHub CLI, Docker, the npm tools, uv, ruff, Poetry. Go falls back to 1.27.4 when the version response is not recognized | | Kept when the image has them | Bun, Rust, Nix, pkgx, GitHub CLI; Docker when the Docker daemon, Docker Compose and Docker Buildx are all installed | | From the image's package repositories | Python 3, pip, venv, pipx, the command-line tools, the headers. pipx is installed with pip if it is not available there | | Best effort: one that fails to install is left out, and the computer is still created | Yarn, pnpm, the AI coding CLIs, the npm tools, pip, venv, pipx, uv, ruff, Poetry, rust-analyzer, gopls, Delve, individual command-line tools, the development headers | - Node.js 26 (26.13.1 on a fresh image) with npm, plus Yarn and pnpm through Corepack. If Corepack cannot be installed, Yarn and pnpm are installed with npm instead. If Corepack cannot be enabled or activated, Yarn or pnpm may not work - TypeScript, ts-node, tsx, ESLint, Prettier, Biome, nodemon, concurrently, npm-check-updates - AI coding CLIs: Claude Code, Codex, opencode, Gemini CLI (no credentials are included) - Bun - The image's Python 3 (installed only if missing), with pip, venv and pipx, plus uv, ruff and Poetry through pipx - Rust (stable, through rustup) with rust-analyzer - Go, with gopls and Delve - Nix and pkgx - GitHub CLI, Docker Engine, Docker Compose and Docker Buildx. The Docker daemon is not running when the computer starts: the first `docker` command starts it. The default user can run `docker` without `sudo` - Command-line tools, including ripgrep, fd, bat, fzf, jq, yq, httpie, Neovim, git-lfs, delta, gdb, valgrind, Clang and LLVM, and the PostgreSQL, MySQL and Redis clients - Development headers (OpenSSL, libffi, zlib, SQLite, PostgreSQL, MariaDB, libxml2 and others) so native extensions compile ## Realms `realm_ids` assigns a computer to realms for API-level isolation. Realms are not private networks; they segregate the Hoody API. See [Realms](/foundation/hoody-api/realms/). ```json { "realm_ids": ["64a2c4e9f3d5e2b6a8c7d8e1", "65b3d5f0a4e6f3c7b9d8e9f2"] } ``` | Rule | Detail | |---|---| | Endpoints | Each realm has its own API endpoint, `https://{realmId}.api.hoody.com`, so production, staging and development are separated at API level | | Tokens | Auth tokens can be scoped to realms. An AI agent using a token limited to realm A cannot discover or manage computers in realm B | | AI agents | Give each AI agent its own realm and a token restricted to it. An agent holding an unrestricted token can still reach other realms, so placing its computer in a realm is not enough on its own | | Create from a realm-scoped host | The target project must already include that realm. The scoped realm is merged into the computer's `realm_ids`, and realm-restricted auth tokens are forced to it only | | Realm limit | A create, copy or update that brings in a realm ID your account does not use yet is refused with `400 REALM_LIMIT_REACHED` when your account is at its [realm limit](/foundation/hoody-api/realms/#realm-limits), and nothing changes. Realms you already use are never refused | ## SSH keys Each computer needs its own SSH public key: Hoody's SSH Proxy routes by public key, so two computers cannot share one SSH identity. Without a key of its own, a computer has no SSH access until you set one with an update. With Hoody Kit installed (the default), [Hoody Terminal](/kit/terminals/) still gives you a shell over HTTP. A computer created with `hoody_kit: false` has neither, so set an SSH key for it. SSH is useful for local tools such as VS Code Remote and rsync, but not required for day-to-day work. See [SSH Access](/foundation/networking/ssh/). ```bash # Generate new key pair for each computer ssh-keygen -t ed25519 -f ~/.ssh/hoody-computer-1 -N "" ssh-keygen -t ed25519 -f ~/.ssh/hoody-computer-2 -N "" ``` ```text computer_1: {"ssh_public_key": "ssh-ed25519 AAAA... (from computer-1.pub)"} computer_2: {"ssh_public_key": "ssh-ed25519 AAAA... (from computer-2.pub)"} ``` ## Colors ```json { "color": "#3498db" } ``` The scheme borrows from Qubes OS, which uses color to mark security domains (red for untrusted, green for trusted). A color makes a computer identifiable in a long list without reading its name. Pick a scheme and keep to it: | Scheme | Colors | |---|---| | WebOS builders | One per workspace or application | | Security zones | Red for public-facing, green for internal services, blue for databases | | Multi-user teams | One per user or team | | Environment types | Yellow for development, orange for staging, green for production | ## RAM disk On the free server and paid subservers, `ramdisk: true` requests temporary RAM storage at `/ramdisk`; `ramdisk: false` leaves it out. Computers running directly on a physical server do not receive the managed mount. See [/ramdisk](/foundation/storage/ramdisk/) for usage patterns and memory balancing. | Rule | Detail | |---|---| | Memory | Allocated as you write, so an empty `/ramdisk` consumes none. It counts against your server's memory, not its disk space | | Capacity | On servers with the managed RAM disk, one memory pool is shared by your computers on that server: 512 MiB by default, capped at 50% of the server's memory, not adjustable | | Lifetime | Survives computer restarts; lost when the host machine reboots | | `ramdisk_scope` | Accepts `computer`. Sharing `/ramdisk` across a project's computers is temporarily unavailable: a request with `ramdisk_scope: project` is refused, and `/ramdisk` stays private to each computer. Share files through [storage shares](/foundation/storage/sharing-files/) instead | | Uses | Caches, build artifacts and temporary processing that needs the speed | ## Update rules | Rule | Detail | |---|---| | `autostart` | Enabling it returns `409 Conflict` until a network policy is in force and any hard access suspension is lifted | | `realm_ids` | Auth tokens restricted to realms cannot change it | | Environment variables | Changes do not generally require a restart: after a successful live sync, new exec and console processes see them. The [`computers env` endpoints](/api/computer-env/) also update `/etc/environment` for new SSH and console logins | `environment_vars` replaces the entire map. Include every variable you want to keep; omitted variables are removed. ```http # Switch from staging to production PATCH /api/v1/computers/{id} { "environment_vars": { "NODE_ENV": "production", "API_BASE_URL": "https://api.mycompany.com" } } ``` ```http # Assign the computer to the production API realm PATCH /api/v1/computers/{id} { "realm_ids": ["64a2c4e9f3d5e2b6a8c7d8e1"] } ``` ## Delete refusals A delete is irreversible and takes the computer's snapshots with it. Its aliases, status logs, SSH keys and storage shares are deleted with it too. If `DELETE /api/v1/computers/{id}` is refused, check: | Check | Rule | |---|---| | Permissions | You own the computer, and your auth token has `computers.delete` and a realm that covers the computer | | Default computer | Your account's auto-provisioned default computer cannot be deleted unless it has expired (for example, after its host was reinstalled) | | Mid-claim | A computer still `claiming` is refused until it reaches `running`. Retry shortly | | Quarantine | A quarantined computer is normally refused. The quarantine restriction does not apply if it is `host_reinstalled` or its `failure_reason.code` is `CREATE_NOT_STARTED`; other delete restrictions still apply. Otherwise, contact support | ## Hoody Kit services `hoody_kit: true` installs the full Hoody Kit HTTP stack. Installation is part of the create. See [The Hoody Kit](/kit/) for complete service documentation. Some of the services: | Service | What it does | |---|---| | [Hoody Terminal](/kit/terminals/) (`hoody-terminal`) | Web-based terminal | | [Hoody Displays](/kit/displays/) (`hoody-display`) | Full desktop environment | | [Hoody Browser](/kit/browser/) (`hoody-browser`) | Chromium and Firefox automation | | [Hoody Files](/kit/files/) (`hoody-files`) | Filesystem access | | [Hoody SQLite](/kit/sqlite/) (`hoody-sqlite`) | Database and KV store | | [Hoody Exec](/kit/exec/) (`hoody-exec`) | Scripts as HTTP APIs | | [Hoody cURL](/kit/curl/) (`hoody-curl`) | HTTP request wrapper | | [Hoody Daemon](/kit/daemons/) (`hoody-daemon`) | Process management | | [Hoody Notifications](/kit/notifications/) (`hoody-notifications`) | Alerts | | [Hoody Code](/kit/code/) (`hoody-code`) | VS Code instances | | [Hoody Cron](/kit/cron/) (`hoody-cron`) | Scheduled task runner | | [Hoody Pipe](/kit/pipe/) (`hoody-pipe`) | Data streaming between services | | [Hoody Agent](/kit/agent/) (`hoody-agent`) | AI coding agent with a browser terminal interface and an HTTP API | ## Lifecycle states A common create, run and stop path; the table adds the exceptional states. ```text creating → running → (paused) → stopped ↓ ↑ (can pause) (can restart) ``` | State | Description | Transitions available | |---|---|---| | `claiming` | Being made ready for you | → `running` (automatic) | | `creating` | Computer being provisioned | → `running` (automatic) | | `running` | Computer is active | → `stopped`, `paused` | | `paused` | Computer suspended | → `running` (resume) | | `stopped` | Computer is stopped | → `running` (start) | | `failed` | Creation or operation failed | Delete it (cleanup) | | `copying` | Being created as a copy | → `running` (when complete); → `stopped` if the copy was made with `copy_network_rules: true` and network setup or automatic start fails | | `host_reinstalled` | Its server was reinstalled, and its files are gone. Left out of computer lists unless `include_expired=true`; it can't start or run commands | Removed (delete it) | Deletion has no state to poll. After a successful `DELETE /api/v1/computers/{id}` returns `200`, the computer is gone and `GET /api/v1/computers/{id}` returns `404`; do not wait for a `deleted` status. Read the current state: [Managing Computers](/foundation/computers/managing/) covers state transitions. ## List and filter `GET /api/v1/computers/` lists all computers for your account, and `GET /api/v1/projects/{id}/computers` the computers in one project. Add `runtime=true` to `GET /api/v1/computers/{id}` for live runtime information. `runtime_info.services` includes service status and PIDs; `runtime_info.network_services` includes listening ports. In the list, `page` and `limit` page the results, `realm_id` filters by realm, and `sort_by` and `sort_order` sort them ([list call](/api/computers/#list-computers)). ## Limits | Limit | Value | |---|---| | Computers per server | 3 on a free server, the plan's limit on a paid subserver, or an explicit `max_computers` where one is set. Rented servers have no limit by default. Stopped computers count; failed and deleted ones do not ([Pricing](/foundation/pricing/)) | | Over the server limit | `400 SERVER_COMPUTER_LIMIT`; nothing is created. Delete a computer on that server, or upgrade when the error offers it in `data.upgrade` | | Computers per project | The optional `max_computers` quota, unset by default, so there is no per-project cap unless you set one. Read it with `GET /api/v1/projects/{id}`; over it, a create returns `400 PROJECT_COMPUTER_LIMIT` | | Aliases per server | By default, 3 on a free server, 50 on Plus, 250 on Pro, and 5,000 on a rented or bare-metal server. An explicit server limit takes precedence. Over the limit, creating an alias returns `422` with `data.field` set to `proxy_alias_limit` and the same `data.upgrade` kinds ([Alias limit reached](/foundation/proxy/aliases/reference/#alias-limit-reached)) | | Platform-wide | None, so you can create as many projects as you need | | Stopped computers | Not charged themselves, but they count toward the server limit and keep their files on its disk. Delete computers you no longer use | | `data.upgrade` | What to do | |---|---| | `{"kind": "buy_paid_subserver"}`, on a free server | Buy a [paid subserver](/foundation/servers/paid-subservers/) and create the computer there | | `{"kind": "upgrade_subscription", "subscription_id": "..."}`, on a paid subserver whose plan can grow | [Upgrade that subscription](/foundation/servers/paid-subservers/#upgrade-a-paid-subserver) | | No `upgrade` field | Delete a computer, or use another server | ## Create retries If the first attempt failed without leaving a computer, retrying runs creation again. Otherwise, repeating the same `Idempotency-Key` and body within 24 hours replays the result with the `Idempotent-Replayed: true` header: | The first create | The answer | |---|---| | Succeeded | `201` with the computer | | Stopped before finishing | `409` `COMPUTER_CREATE_INTERRUPTED`, with the computer it made in `data.computer_id`. Check its status, and delete it if you do not want it | | Failed | Its error | | Succeeded, but its computer was since deleted | `404` | The SDK and CLI send the same key again when they retry after a lost connection, so a retry returns the first create's computer instead of making a second one; while that create is still running, they wait and ask again. A create that repeats a name in use answers `409` `COMPUTER_NAME_IN_USE` and, when you can see it, the existing computer's id in `data.computer_id`. Key format and in-progress answers: the [create call](/api/computers/#create-and-authorize-computers). ## Recipes Each recipe is a complete create request body. Replace `server_id` and `ssh_public_key` with your own. ### Development computer The full Kit stack, AI enabled, autostart on, and a color for the UI. Use it as a day-to-day working computer that comes back automatically after a host reboot. ### Production API computer Scoped to a single realm, on `debian/13`, with the app's environment set at creation. Then create a [proxy alias](/foundation/proxy/aliases/) for a clean URL, set [proxy permissions](/foundation/proxy/permissions/#configure-permissions) for authentication, and configure [firewall rules](/foundation/networking/firewall/) for security. ### Minimal utility computer A computer that does not come back after a host reboot, for backup jobs you run occasionally. ### AI agent computer For AI orchestration, with the provider keys passed as environment variables. The Hoody Agent service is then reachable at: ```text https://67e89abc123def456789abcd-890abcdef12345678901cdef-agent-1.node-us.computers.hoody.com ``` ### From project to running computer Create a project, pick a server, create a computer, and confirm it is running. The SSH key must be the full contents of a public key file, such as `~/.ssh/acme-frontend.pub`; a shortened key is refused. Set `SSH_PUBLIC_KEY` to it for the SDK, HTTP and URL tabs. A key can be on one computer only. Set `PROJECT_ID`, `SERVER_ID` and `COMPUTER_ID` from the responses of steps 1 to 3 (the project's id, your active rental's `server_id`, the new computer's id). After creation, repeat the status request until `data.status` is `running`. If it becomes `failed`, inspect `failure_reason` and follow [Troubleshooting](#troubleshooting). Open service URLs only after the computer is running and its services are ready. ```bash # 1. Create a project hoody projects create --alias "client-acme" --color "#e74c3c" # 2. Check your servers: use the server_id field, not the rental id hoody servers list -o json # 3. Create a computer hoody computers create --project "$PROJECT_ID" \ --server-id "$SERVER_ID" \ --name "acme-frontend" \ --hoody-kit \ --ssh-public-key "$(cat ~/.ssh/acme-frontend.pub)" # 4. Verify it's running hoody computers get "$COMPUTER_ID" # 5. Use these URLs after the computer and services are ready: # https://{projectId}-{computerId}-terminal-1.{server}.computers.hoody.com # https://{projectId}-{computerId}-display-1.{server}.computers.hoody.com ``` ```typescript import { HoodyClient } from 'hoody-sdk'; const client = new HoodyClient({ baseURL: 'https://api.hoody.com', token: process.env.HOODY_TOKEN }); // 1. Create a project const project = await client.api.projects.create({ alias: 'client-acme', color: '#e74c3c' }); // 2. Get server ID from rentals const rentals = await client.api.servers.list(); const serverId = rentals.data.find((r) => r.status === 'active' && r.server_id)?.server_id; if (!serverId) throw new Error('No active server available'); // 3. Create a computer const computer = await client.api.computers.create(project.data.id, { name: 'acme-frontend', server_id: serverId, hoody_kit: true, ssh_public_key: process.env.SSH_PUBLIC_KEY // full contents of your .pub file }); // 4. Verify it's running const status = await client.api.computers.get(computer.data.id); console.log(status.data.status); // May still be 'creating'; repeat GET until 'running'. ``` ```bash # 1. Create a project curl -X POST "https://api.hoody.com/api/v1/projects/" \ -H "Authorization: Bearer $HOODY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"alias": "client-acme", "color": "#e74c3c"}' # 2. Check your servers: use the server_id field, not the rental id curl "https://api.hoody.com/api/v1/rentals" \ -H "Authorization: Bearer $HOODY_TOKEN" # 3. Create a computer curl -X POST "https://api.hoody.com/api/v1/projects/$PROJECT_ID/computers" \ -H "Authorization: Bearer $HOODY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "acme-frontend", "server_id": "'"$SERVER_ID"'", "hoody_kit": true, "ssh_public_key": "'"$SSH_PUBLIC_KEY"'" }' # 4. Verify it's running curl "https://api.hoody.com/api/v1/computers/$COMPUTER_ID" \ -H "Authorization: Bearer $HOODY_TOKEN" # 5. Use these URLs after the computer and services are ready: # https://{projectId}-{computerId}-terminal-1.{server}.computers.hoody.com ``` The same four calls as GET links: create the project, check available servers, create the computer, then confirm it's running. Route them through a **different** running computer's curl-1 (`OTHER_PROJECT_ID`, `OTHER_COMPUTER_ID` and `OTHER_SERVER` are that computer's project, id and server): the project and computer don't exist yet, so they can't serve their own creation. In the Hub, open **Computers**, choose **Get a computer**, select the project and server, configure the options, then select **Get computer**. To rename a computer, open its menu, choose **Rename…**, enter the new name, then select **Rename**. To delete it, choose **Delete…**, enter its name to confirm, then select **Delete computer**. ## Change the OS A computer's base image cannot be changed. Creation currently supports `debian/13`. To start with a clean Debian 13 computer, create another computer, transfer the data you need, verify it, then delete the old one. You can transfer data through [storage shares](/foundation/storage/sharing-files/#create-a-share) or a manual copy. ## Practices | Practice | Why | |---|---| | Do nothing special for speed | A plain create is already the fastest path: some finish in under a second without any option, and one that returns a computer already `running` needs nothing more | | Default to `debian/13` | Unless you have a specific requirement: stability, security updates and package availability | | Set `autostart` by priority | Use `autostart: true` for services that must return after a host reboot. Use `autostart: false` when you want to start the computer yourself after a reboot. Stop development computers explicitly to release their running resources between sessions | | Keep snapshots of production computers | For quick rollback. A snapshot is not a backup against deletion or server loss: it stays on the computer's server, and deleting a computer permanently deletes its snapshots. For disaster recovery, also [copy the computer onto another server](/foundation/computers/copy-sync/#cross-server-copy) | | Create in parallel | Creates can run in parallel, subject to your account's create rate limit and each server's capacity. Handle `429` responses and wait for `Retry-After` before retrying. Give each intended computer its own `Idempotency-Key` and reuse that key for its retries | | Automate with CI/CD | Create an [auth token](/foundation/hoody-api/authentication/#create-an-automation-token), store it as a GitHub secret, and call `curl` from your workflow. Creation is an HTTP POST, so it works in any CI/CD system | ## API calls | Task | Call | |---|---| | Create a computer | `POST /api/v1/projects/{id}/computers` | | List all computers | `GET /api/v1/computers/` | | List a project's computers | `GET /api/v1/projects/{id}/computers` | | Get computer details | `GET /api/v1/computers/{id}` | | Update computer configuration | `PUT` or `PATCH /api/v1/computers/{id}` | | Delete a computer permanently | `DELETE /api/v1/computers/{id}` | | Start, stop, pause, resume | [Computer Operations](/api/computer-operations/) | | Project management | [Projects](/api/projects/) | ## Troubleshooting | Symptom | Cause | What to do | |---|---|---| | Status stays `creating` | Creates take a few seconds, some a few minutes. Complex images and the first creation on a server take longer | Past 2 minutes, check with `hoody servers list -o json` or `GET /api/v1/rentals` that the rental is active. With a full-account signed-in session on the base API domain, you can also inspect `server.computer_capacity` for your current free server. API tokens, HTTP Basic and realm-scoped requests omit this field. Past 5 minutes, try deleting and recreating the computer, or contact support with its `computer_id`. If a create is refused with `SERVER_COMPUTER_LIMIT`, use the error's capacity details to choose another server or free a slot | | `status: "failed"`, right away or later | Server out of capacity (CPU or RAM), network issues. An unknown image or a full server or project quota is a `400` at create instead, and nothing is made | Read `failure_reason` (`CREATE_NOT_STARTED`, `CREATE_FAILED` or `COPY_FAILED`) with `GET /api/v1/computers/{id}`, and choose a different server if it is full. For `CREATE_NOT_STARTED`, delete and recreate the computer. For other failures, try deleting it before recreating; if deletion is refused because it is quarantined, contact support with its `computer_id` | | Create returns `400` listing images | The name does not resolve to a base image the platform carries, `debian/13` | Shorthand is normalized: `debian`, `debian-13` and `debian:13` all resolve to `debian/13` | | `409 COMPUTER_NAME_IN_USE` on create or update | The name must be unique within the project | Choose another name, or use the computer in `data.computer_id` | | `409 SSH_PUBLIC_KEY_IN_USE` on create or update | The key is on another computer; it cannot be reused | Generate a new key pair | | Update returns `422` with `error: "Validation Error"` | The request does not match the schema, for example an invalid hexadecimal color or malformed `realm_ids` | Correct the invalid field and retry. Fixed fields such as `computer_image`, `hoody_kit` and `server_id` are ignored by updates; create another computer to change them | | Service URLs return errors after creation | Not `running` yet, services still initializing, or `hoody_kit` not enabled | Check `GET /api/v1/computers/{id}` shows `status: "running"`, then wait 30-60 seconds after it. Check `?runtime=true` lists the services in `runtime_info`, and that `"hoody_kit": true` |