Explore the Kit
Every HTTP service built into a Kit computer, including the AI agent: browser, cron, notes, pipes, tunnels and more. The Hoody Kit →
Hoody gives you Linux computers in the cloud. Everything that runs on one has its own HTTPS link: a terminal, a file, a database, a desktop, a website you start on a port.
A free account comes with a free server: 2 cores, 3 GB RAM and 20 GB disk, shared by up to 3 computers. Your first computer is already on it, with the 20 HTTP services of the Hoody Kit. One of them is the Hoody Agent, which runs on Hoody AI’s free tier. The server does not expire, and computers are not charged. Limits can change: Pricing has the current ones.
On this page you sign in, open that computer’s desktop in a browser tab and put a website online. Then you script it: run a command, write a file, query a database and give the Hoody Agent a task. Each step has a tab for the CLI, the TypeScript SDK and plain curl, and most have a link you can open.
Every call is an ordinary HTTPS request. There is nothing to install on the computer, and no deployment step, certificate, port or proxy to configure. An iframe, a webhook or an AI agent calls the same URLs the same way. The CLI and HTTP tabs use jq; the SDK tabs need Node.js 20.19 or later (everything you need).
Pick the fastest way for where you are. Each one creates the same account.
| From | Do this |
|---|---|
| A terminal, nothing installed | Run ssh hoody.com. After the terms notice, its welcome menu creates an account or signs you in. |
| A browser | Sign up at hoody.com/signup, then open the Hub at hub.hoody.com. |
| Node.js | Run npx hoody-sdk@1.0.1 signup. It asks for an email and a password, verifies the email and ends signed in. |
| An AI chat | Paste @https://hoody.com Connect to Hoody. Your AI sends you a signup link and, once you approve its sign-in, works on your account for you (Connect Your AI to Hoody). |
Verify your email before signing in. A verified new account comes with a free server and a first computer (what an account needs). To follow the next steps, sign in from the interface you want to use:
# Install the CLI (it ships inside the hoody-sdk package)...npm install -g hoody-sdk@1.0.1# ...or skip the install entirely: npx hoody-sdk@1.0.1 <command>
# Interactive sign-in (`hoody signup` if you don't have an account yet)hoody login# If it offers to open the Hub, press n to stay in your shellStandalone binaries for Linux, macOS and Windows need no Node.js: Install.
// npm install hoody-sdk@1.0.1import { HoodyClient } from 'hoody-sdk';
// Returns a signed-in client. Signed up with a username? Pass `username` instead of `email`.const hoody = await HoodyClient.login('https://api.hoody.com', { email: process.env.HOODY_EMAIL!, password: process.env.HOODY_PASSWORD!,});The SDK tabs on this page continue one program. Save them in one file, quickstart.mts, and run it with npx tsx quickstart.mts.
# Sign in once more and keep only the access token (or mint a scoped one with `hoody auth tokens create`).# It prompts like `hoody login`; --no-save leaves the CLI's own saved session untouched.export HOODY_TOKEN=$(hoody login --print-token --no-save)
# Each signed-in call below carries it as a Bearer headercurl -H "Authorization: Bearer $HOODY_TOKEN" \ https://api.hoody.com/api/v1/users/auth/meA link runs through a computer, so it needs the three values from Step 2. Sign in from another tab.
Your account holds servers, a project organizes computers, and a computer is a full Linux computer running Debian 13 with systemd. The free server already holds one computer with the Hoody Kit, in a project named Default. List your computers and keep three values of a running one: its ID, its project ID and its server_name.
# Take a running computer (-o json prints the response data itself, no envelope to unwrap)COMPUTER=$(hoody computers list -o json \ | jq '[.computers[] | select(.status == "running")][0]')COMPUTER_ID=$(echo "$COMPUTER" | jq -r '.id')PROJECT_ID=$(echo "$COMPUTER" | jq -r '.project_id')SERVER_NAME=$(echo "$COMPUTER" | jq -r '.server_name')
# Make it the CLI's default computer, for commands without -choody config set computer "$COMPUTER_ID"// Take a running computerconst list = await hoody.api.computers.list();const computer = list.data?.computers?.find(c => c.status === 'running');if (!computer) throw new Error('No running computer yet: run this again in a moment');
// hoody.api.* is your account. box.* is this computer: box.terminal, box.files, box.sqlite, ...const box = await hoody.withComputer(computer);# Take a running computerCOMPUTER=$(curl -s -H "Authorization: Bearer $HOODY_TOKEN" \ https://api.hoody.com/api/v1/computers/ \ | jq '[.data.computers[] | select(.status == "running")][0]')COMPUTER_ID=$(echo "$COMPUTER" | jq -r '.id')PROJECT_ID=$(echo "$COMPUTER" | jq -r '.project_id')SERVER_NAME=$(echo "$COMPUTER" | jq -r '.server_name')A link runs through a computer, so it needs the three values this step finds. Read them from another tab.
A computer on a new account can still be setting up: if the list has no running one, run the step again in a moment (Troubleshooting).
Once the computer is running, its Kit services answer at stable HTTPS URLs. A service may still be starting; retry its request if it is temporarily unavailable.
https://{projectId}-{computerId}-{service}[-{instance}].{server}.computers.hoody.com{server} is the computer’s server_name. The Hoody Kit lists every service on that pattern: two use short URL slugs (notifications → n, proxyLogs → logs), and http-{port} covers anything you start on a port. The next steps use seven of them, counting the curl-1 service that sends each link.
Kit services with a screen open as pages, with no client to install on the device you use. Paste either link into a browser, with your three values in place:
https://{projectId}-{computerId}-desktop-1.{server}.computers.hoody.comhttps://{projectId}-{computerId}-terminal-1.{server}.computers.hoody.comThe first starts an Xfce desktop if none is running, then shows it once it is ready. The second is a shell in terminal 1, the same terminal that runs the command in Step 4.
In the Hub, open Computers and select your computer. On its Overview tab, under Open on followed by your computer’s name, select the Desktop or Terminal tile. It opens in a new browser tab.
# Open the desktop in your browser (add --url to print the link instead)hoody desktop open -c "$COMPUTER_ID"
# Open terminal 1 as a web terminalhoody terminal open 1 -c "$COMPUTER_ID"console.log(hoody.getDesktopUrl(computer)); // the desktop-1 linkconsole.log(hoody.getKitUrl('terminal', computer, 1)); // the terminal-1 link# Pages, not API calls: print the links, then open them in a browserecho "https://$PROJECT_ID-$COMPUTER_ID-desktop-1.$SERVER_NAME.computers.hoody.com"echo "https://$PROJECT_ID-$COMPUTER_ID-terminal-1.$SERVER_NAME.computers.hoody.com"https://PROJECT_ID-COMPUTER_ID-desktop-1.SERVER_NAME.computers.hoody.comhttps://PROJECT_ID-COMPUTER_ID-terminal-1.SERVER_NAME.computers.hoody.comReplace the three names, then open each link in a browser tab.
files-1 opens a file manager and code-1 opens VS Code the same way. Displays covers GUI programs and driving a desktop over HTTP, and Embed a Kit UI in your own page covers putting these pages in an iframe.
Start any HTTP server on a port inside the computer, and that port has its own HTTPS link: put http-{port} where the service label goes. This command writes a one-line page and serves it on port 3000. You can also type it into the web terminal from Step 3.
# Write a page and start a web server on port 3000 inside your computerhoody terminal commands run -c "$COMPUTER_ID" --terminal-id 1 \ --command 'mkdir -p /home/user/site && echo "<h1>Hello from Hoody</h1>" > /home/user/site/index.html; nohup python3 -m http.server 3000 --directory /home/user/site >/tmp/site.log 2>&1 & sleep 1'
# It's already on the public internet, with HTTPScurl "https://$PROJECT_ID-$COMPUTER_ID-http-3000.$SERVER_NAME.computers.hoody.com/"// Write a page and start a web server on port 3000 inside your computerawait box.terminal.commands.run({ command: 'mkdir -p /home/user/site && echo "<h1>Hello from Hoody</h1>" > /home/user/site/index.html; nohup python3 -m http.server 3000 --directory /home/user/site >/tmp/site.log 2>&1 & sleep 1', wait: true,}, { terminal_id: '1' });
// It's already on the public internet, with HTTPSconst site = hoody.getKitUrl('http', computer, { port: 3000 });console.log(site, await (await fetch(site)).text());# Write a page and start a web server on port 3000 inside your computercurl -X POST \ "https://$PROJECT_ID-$COMPUTER_ID-terminal-1.$SERVER_NAME.computers.hoody.com/api/v1/terminal/execute?terminal_id=1" \ -H "Content-Type: application/json" \ -d '{"command": "mkdir -p /home/user/site && echo \"<h1>Hello from Hoody</h1>\" > /home/user/site/index.html; nohup python3 -m http.server 3000 --directory /home/user/site >/tmp/site.log 2>&1 & sleep 1", "wait": true}'
# It's already on the public internet, with HTTPScurl "https://$PROJECT_ID-$COMPUTER_ID-http-3000.$SERVER_NAME.computers.hoody.com/"The first link writes the page and starts a background web server on port 3000. The second fetches the page through the computer’s public http-3000 URL, which also opens directly in a browser. Neither carries a token while the project sets no proxy permissions.
# Start the web serverhttps://PROJECT_ID-COMPUTER_ID-curl-1.SERVER_NAME.computers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-COMPUTER_ID-terminal-1.SERVER_NAME.computers.hoody.com/api/v1/terminal/execute?terminal_id=1&method=POST&json={"command":"mkdir%20-p%20/home/user/site%20%26%26%20echo%20\"<h1>Hello%20from%20Hoody</h1>\"%20>%20/home/user/site/index.html;%20nohup%20python3%20-m%20http.server%203000%20--directory%20/home/user/site%20>/tmp/site.log%202>%261%20%26%20sleep%201","wait":true}&response=transparent
# Fetch the pagehttps://PROJECT_ID-COMPUTER_ID-curl-1.SERVER_NAME.computers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-COMPUTER_ID-http-3000.SERVER_NAME.computers.hoody.com/&method=GET&response=transparentOne request, one link
cURL runs inside your computer and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.
Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials. It also appears in the cURL service's request log, not only the target's. Prefer a delegated token with minimal permissions and an expiry: see API tokens.
Slashes, colons and braces pass through as they are. The one character you must
encode is an & inside a value, which happens when the wrapped URL
carries its own query string. Left raw it ends the value early, and the rest is
read as cURL's own parameters, so you get a 200 on a request you did
not make.
How the wrapping works Chaining calls into one link Turning a link into a shortcut
Open the http-3000 link in a browser to see the page. Have your own servers listen on all addresses (0.0.0.0 or ::) (bind addresses). A proxy alias gives the port a hostname you choose or your own domain, Hoody Daemon starts the server and restarts it by your rules, and a script file becomes a live HTTP endpoint with no server in Your First API.
In the Hub, open Computers, select the computer and open its Run tab. Type the command into Command and press Run.
# Execute a shell command on your computerhoody terminal commands run -c "$COMPUTER_ID" --ephemeral \ --command "grep PRETTY_NAME /etc/os-release"// One-shot helper: runs the command without a terminal session, waits, and returns stdout and stderrconst output = await box.terminal.run('grep PRETTY_NAME /etc/os-release');console.log(output.stdout); // the computer's Debian release# Send ephemeral=true to the terminal-0 hostname: on any terminal-N hostname the proxy# forces terminal_id=N and ephemeral can no longer auto-generate an isolated session id.curl -s -X POST \ "https://$PROJECT_ID-$COMPUTER_ID-terminal-0.$SERVER_NAME.computers.hoody.com/api/v1/terminal/execute?ephemeral=true" \ -H "Content-Type: application/json" \ -d '{"command": "grep PRETTY_NAME /etc/os-release", "wait": true}' | jq -r '.stdout'Runs the command in a one-off terminal session and returns its result as JSON, with the output in stdout. No token needed while the project sets no proxy permissions: the project/computer id pair in the URL is the credential.
https://PROJECT_ID-COMPUTER_ID-curl-1.SERVER_NAME.computers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-COMPUTER_ID-terminal-0.SERVER_NAME.computers.hoody.com/api/v1/terminal/execute?ephemeral=true&method=POST&json={"command":"grep%20PRETTY_NAME%20/etc/os-release","wait":true}&response=transparentOne request, one link
cURL runs inside your computer and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.
Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials. It also appears in the cURL service's request log, not only the target's. Prefer a delegated token with minimal permissions and an expiry: see API tokens.
Slashes, colons and braces pass through as they are. The one character you must
encode is an & inside a value, which happens when the wrapped URL
carries its own query string. Left raw it ends the value early, and the rest is
read as cURL's own parameters, so you get a 200 on a request you did
not make.
How the wrapping works Chaining calls into one link Turning a link into a shortcut
The CLI and HTTP answers are the finished result: stdout, exit_code and a command_id that fetches the same result again (what each step returns). The SDK helper returns stdout, stderr, exitCode, timedOut, duration and commandId. It runs the command without a terminal session, so its result cannot be fetched again. For an interactive shell from your own terminal, run hoody shell "$COMPUTER_ID".
Replace the page from Step 4 through the Files service, then read it back. Reload your http-3000 link and the site has changed.
In the Hub, open Files, pick your computer and browse to /home/user/site. On index.html, Open in editor opens the computer’s editor, where you change and save the file, and Preview shows it.
# Write a file: the body comes from stdinecho '<h1>Changed over HTTP</h1>' \ | hoody files upload /home/user/site/index.html -c "$COMPUTER_ID"
# Read a file from your computer (-o raw prints it verbatim)hoody files get -c "$COMPUTER_ID" /home/user/site/index.html -o rawawait box.files.upload('/home/user/site/index.html', '<h1>Changed over HTTP</h1>');
const file = await box.files.get('/home/user/site/index.html', { responseType: 'text' });console.log(file.data);curl -X PUT "https://$PROJECT_ID-$COMPUTER_ID-files-1.$SERVER_NAME.computers.hoody.com/api/v1/files/home/user/site/index.html" \ --data-binary '<h1>Changed over HTTP</h1>'
curl "https://$PROJECT_ID-$COMPUTER_ID-files-1.$SERVER_NAME.computers.hoody.com/api/v1/files/home/user/site/index.html"The first link writes the file, replacing the one that exists. The second returns the file’s raw bytes. No token needed while the project sets no proxy permissions: the project/computer id pair in the URL is the credential.
# Write the filehttps://PROJECT_ID-COMPUTER_ID-curl-1.SERVER_NAME.computers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-COMPUTER_ID-files-1.SERVER_NAME.computers.hoody.com/api/v1/files/home/user/site/index.html&method=PUT&data=<h1>Changed%20over%20HTTP</h1>&response=transparent
# Read it backhttps://PROJECT_ID-COMPUTER_ID-curl-1.SERVER_NAME.computers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-COMPUTER_ID-files-1.SERVER_NAME.computers.hoody.com/api/v1/files/home/user/site/index.html&method=GET&response=transparentOne request, one link
cURL runs inside your computer and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.
Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials. It also appears in the cURL service's request log, not only the target's. Prefer a delegated token with minimal permissions and an expiry: see API tokens.
Slashes, colons and braces pass through as they are. The one character you must
encode is an & inside a value, which happens when the wrapped URL
carries its own query string. Left raw it ends the value early, and the rest is
read as cURL's own parameters, so you get a 200 on a request you did
not make.
How the wrapping works Chaining calls into one link Turning a link into a shortcut
Every Kit computer ships a SQLite service; there is no database server to provision and no connection string to configure.
In the Hub, open Computers, select the computer and open its Connect tab. Open SQLite under Program links, create or open a database, then open Query, type the SQL and press Execute.
# Run a SQL transaction on the built-in SQLitehoody db transactions run -c "$COMPUTER_ID" --db app --create-db-if-missing \ --transaction '[{"statement":"CREATE TABLE IF NOT EXISTS greetings (message TEXT)"},{"statement":"INSERT INTO greetings VALUES ('"'"'Hello, Hoody!'"'"')"},{"query":"SELECT * FROM greetings"}]' \ -o jsonconst result = await box.sqlite.sql.runTransaction( { transaction: [ { statement: "CREATE TABLE IF NOT EXISTS greetings (message TEXT)" }, { statement: "INSERT INTO greetings VALUES ('Hello, Hoody!')" }, { query: "SELECT * FROM greetings" }, ], }, { db: 'app', create_db_if_missing: true },);console.log(result.data);// → results: [..., { success: true, resultHeaders: ['message'], resultSet: [{ message: 'Hello, Hoody!' }] }]curl -X POST "https://$PROJECT_ID-$COMPUTER_ID-sqlite-1.$SERVER_NAME.computers.hoody.com/api/v1/sqlite/db?db=app&create_db_if_missing=true" \ -H "Content-Type: application/json" \ -d '{"transaction": [{"statement": "CREATE TABLE IF NOT EXISTS greetings (message TEXT)"}, {"statement": "INSERT INTO greetings VALUES ('"'"'Hello, Hoody!'"'"')"}, {"query": "SELECT * FROM greetings"}]}'Creates the table if missing, inserts a row, and returns the select in one transaction. No token needed while the project sets no proxy permissions: the project/computer id pair in the URL is the credential.
https://PROJECT_ID-COMPUTER_ID-curl-1.SERVER_NAME.computers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-COMPUTER_ID-sqlite-1.SERVER_NAME.computers.hoody.com/api/v1/sqlite/db?db=app%26create_db_if_missing=true&method=POST&json={"transaction":[{"statement":"CREATE%20TABLE%20IF%20NOT%20EXISTS%20greetings%20(message%20TEXT)"},{"statement":"INSERT%20INTO%20greetings%20VALUES%20('Hello,%20Hoody!')"},{"query":"SELECT%20*%20FROM%20greetings"}]}&response=transparentOne request, one link
cURL runs inside your computer and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.
Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials. It also appears in the cURL service's request log, not only the target's. Prefer a delegated token with minimal permissions and an expiry: see API tokens.
Slashes, colons and braces pass through as they are. The one character you must
encode is an & inside a value, which happens when the wrapped URL
carries its own query string. Left raw it ends the value early, and the rest is
read as cURL's own parameters, so you get a 200 on a request you did
not make.
How the wrapping works Chaining calls into one link Turning a link into a shortcut
Hoody does not host the agent: your own computer serves it, so every Kit computer carries its own, directly at:
https://{projectId}-{computerId}-agent-1.{server}.computers.hoody.comOpen it in any browser, embed it in an iframe or share it with a teammate: a phone, a laptop, a TV and a tablet all reach the same environment and the same state. The agent that manages your computers itself runs in a computer.
Hoody also has a browser interface: sign in at hub.hoody.com and you land in the Hub. Press AI in its top bar to open the Agent panel, which chats with the Hoody Agent on the computer picked in the top bar. The Hub’s pages manage your computers, files, Bots and billing. In a terminal on Linux x86-64 or arm64, the standalone hoody binary or the npm package with Node 26 or later opens the same Hub with hoody hub (the Hub in your terminal).
The agent starts on Hoody AI’s free tier, with no model key to set up, and works on its own computer without signing in. Give it a task. This one rewrites the page from Step 4, so the result is on your http-3000 link when the turn ends.
In the Hub, pick the computer in the top bar, press AI and type the task into the Agent panel.
# --gate-policy auto_approve approves the agent's ordinary confirmations for this turnhoody agent prompt "Rewrite /home/user/site/index.html as a landing page for a bakery." \ --gate-policy auto_approve -c "$COMPUTER_ID"const session = await box.agent.sessions.create();const sessionId = session.data?.session_id;if (!sessionId) throw new Error('The agent did not create a session');
// gatePolicy approves the agent's ordinary confirmations for this turn.// The request waits up to 290 s for the turn, longer than the SDK's 30 s default.// A longer turn keeps running: the call returns pending_gate if human input is needed, otherwise HTTP 503.const turn = await box.agent.sessions.turns.run(sessionId, { text: 'Rewrite /home/user/site/index.html as a landing page for a bakery.',}, { gatePolicy: 'auto_approve', timeoutMs: 300_000 });console.log(turn.data);SESSION_ID=$(curl -s -X POST "https://$PROJECT_ID-$COMPUTER_ID-agent-1.$SERVER_NAME.computers.hoody.com/api/v1/agent/sessions" \ -H "Content-Type: application/json" -d '{}' | jq -r '.session_id')
curl -X POST "https://$PROJECT_ID-$COMPUTER_ID-agent-1.$SERVER_NAME.computers.hoody.com/api/v1/agent/sessions/$SESSION_ID/prompt:sync?policy=auto_approve" \ -H "Content-Type: application/json" \ -d '{"text": "Rewrite /home/user/site/index.html as a landing page for a bakery."}'Create returns the session_id to put in place of SESSION_ID. Opening the second link runs the turn, which edits the file in the computer. Ordinary confirmations are approved for you; a gate raised by a tool-call rule is denied, and a human-only gate still waits for a person.
# Create a sessionhttps://PROJECT_ID-COMPUTER_ID-curl-1.SERVER_NAME.computers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-COMPUTER_ID-agent-1.SERVER_NAME.computers.hoody.com/api/v1/agent/sessions&method=POST&json={}&response=transparent
# Give it the taskhttps://PROJECT_ID-COMPUTER_ID-curl-1.SERVER_NAME.computers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-COMPUTER_ID-agent-1.SERVER_NAME.computers.hoody.com/api/v1/agent/sessions/SESSION_ID/prompt:sync?policy=auto_approve&method=POST&json={"text":"Rewrite%20/home/user/site/index.html%20as%20a%20landing%20page%20for%20a%20bakery."}&response=transparentOne request, one link
cURL runs inside your computer and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.
Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials. It also appears in the cURL service's request log, not only the target's. Prefer a delegated token with minimal permissions and an expiry: see API tokens.
Slashes, colons and braces pass through as they are. The one character you must
encode is an & inside a value, which happens when the wrapped URL
carries its own query string. Left raw it ends the value early, and the rest is
read as cURL's own parameters, so you get a 200 on a request you did
not make.
How the wrapping works Chaining calls into one link Turning a link into a shortcut
The CLI streams the reply. Over HTTP and in the SDK, a completed turn returns its status without reply text; the page itself is the result. A turn needing human input can instead return pending_gate and turn_id before it ends. To let the agent reach your account and your other computers, sign it in once. Agent covers sessions, models and your own provider accounts.
Computers have no per-unit cost. Once a server exists, you can create as many as its capacity and limits allow, including your project’s computer limit (max_computers). An experiment, an agent task or a customer can each get its own computer. This creates a second one next to your first, in the same project and on the same server.
In the Hub, open Computers and press Get a computer. Keep the suggested Name or type your own, pick the same Server and Project, and press Get computer. Under More options, Hoody kit is on by default.
# The server your first computer runs onSERVER_ID=$(echo "$COMPUTER" | jq -r '.server_id')
# Spawn a second Kit computer in the same projecthoody computers create --project "$PROJECT_ID" --server-id "$SERVER_ID" \ --name "dev-box" --hoody-kit// Spawn a second Kit computer in the same project, on the same serverconst { data: second } = await hoody.api.computers.create(computer.project_id, { server_id: computer.server_id, name: 'dev-box', hoody_kit: true, // preinstall the Kit service layer: terminal, files, sqlite, agent, ...});console.log(second?.id, second?.status);# The server your first computer runs onSERVER_ID=$(echo "$COMPUTER" | jq -r '.server_id')
# Spawn a second Kit computer in the same projectcurl -X POST "https://api.hoody.com/api/v1/projects/$PROJECT_ID/computers" \ -H "Authorization: Bearer $HOODY_TOKEN" -H "Content-Type: application/json" \ -d '{"server_id": "'"$SERVER_ID"'", "name": "dev-box", "hoody_kit": true}'Replace SERVER_ID with your first computer’s server_id. The link runs through that computer’s curl-1 service and carries your account token.
https://PROJECT_ID-COMPUTER_ID-curl-1.SERVER_NAME.computers.hoody.com/api/v1/curl/request?url=https://api.hoody.com/api/v1/projects/PROJECT_ID/computers&method=POST&bearer_token=HOODY_TOKEN&json={"server_id":"SERVER_ID","name":"dev-box","hoody_kit":true}&response=transparentOne request, one link
cURL runs inside your computer and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.
Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials. It also appears in the cURL service's request log, not only the target's. Prefer a delegated token with minimal permissions and an expiry: see API tokens.
Slashes, colons and braces pass through as they are. The one character you must
encode is an & inside a value, which happens when the wrapped URL
carries its own query string. Left raw it ends the value early, and the rest is
read as cURL's own parameters, so you get a 200 on a request you did
not make.
How the wrapping works Chaining calls into one link Turning a link into a shortcut
The answer carries the new computer’s id and server_name. Wait until its status is running before you call its Kit services. Create a computer and wait for it has the whole script, from picking a server to the wait.
The free server is a shared machine to start on. When you need dedicated hardware, rent flat-rate bare metal from the marketplace: computers stay free; you pay for the machine.
Every way in reaches the same account and the same computers, so switching needs no migration. Ways to connect has the setup and the detail of each one.
| From | Use | Start with |
|---|---|---|
| A browser | The Hub | hub.hoody.com |
| A terminal, nothing installed | SSH | ssh hoody.com |
| A terminal | The Hoody CLI | npm install -g hoody-sdk@1.0.1 |
| TypeScript or JavaScript | The Hoody SDK | npm install hoody-sdk@1.0.1 |
| A static web page | The browser build | One script tag that exposes window.HoodySDK |
| Any language | HTTP | A Bearer token on api.hoody.com, and the computer’s own URLs |
| ChatGPT, Claude, Gemini | The Hoody Skill | Paste @https://hoody.com Connect to Hoody (Connect Your AI to Hoody) |
| A coding agent | The Hoody Skill | npx skills add (below) |
| Telegram, Slack or Discord | A Bot | Chat apps for your Bot |
| Another AI app, or people you trust | A Bot URL | Bot URLs |
If you already work in a coding agent, install the Hoody Skill into it once and it knows the whole HTTP surface without being told each time:
# The skill itself; deeper docs are fetched on demandnpx skills add https://hoody.com/SKILLS/SKILL.md
# The same skill plus the whole corpus on disk, for offline usenpx skills add HoodyNetwork/hoody-sdkWorks with
CLI runs on
The Skill teaches the agent the endpoints; it does not grant access. The agent signs you in through a browser link, or uses a token you give it.
Everything you need before you start, every placeholder, every way to connect, what each step returns, limits and troubleshooting: Quick Start reference.
The Getting started pages continue from here: Understanding computers, The Hoody Proxy and Your First API.
Explore the Kit
Every HTTP service built into a Kit computer, including the AI agent: browser, cron, notes, pipes, tunnels and more. The Hoody Kit →
Put agents and Bots to work
Give an AI agent its own computer, and reach a Bot from Telegram, Slack or Discord. Run an AI agent in a computer → · Chat apps →
Add servers
Share and embed
Decide who can open each URL, then put a terminal, a desktop or a file view in your own page. Proxy permissions → · Embed a Kit UI →