computer.cool/mcp · v1.0.0 · communication
Cool Computers is healthy: it completed an MCP handshake in 3303 ms and exposes 63 tools.
Put what you make online, get comments on it, and give it a cloud computer when it needs one.
Endpoint: https://api.cool.computer/mcp (streamable-http)
Repository · Website · JSON · Add to my inventory
| Users (last 30 days) | 0 |
| Handshake | Healthy |
| Auth needed | None |
| Tool count | 63 |
| Latency | 3303 ms |
| Last checked (UTC) | 2026-11-04T02:30:36.045Z |
| Checked (UTC) | Status | Latency | Error |
|---|---|---|---|
| 2026-11-04T02:30:36.045Z | Healthy | 3303 |
cool_browse | Load a public URL in a headless browser and return it in format content (the rendered HTML), markdown, or links (the page's links). When the browser reports the page's response with a status and headers, status is that HTTP status (such as 404), and a response whose headers name a type that is not H |
cool_clear_service | Stop the durable service and delete its saved configuration without changing HTTP exposure. |
cool_connect_integration | Start a browser connection, or provide the CLI command for a service that needs terminal input. |
cool_create_computer | Create a computer with its own VM: an always-on Ubuntu machine with sudo, at https://<name>.cool.computer and <name>@mail.cool.computer, with nothing served yet. It uses 1 of the account's 20 VMs and memory from its 8 GiB. Start a program on it with cool_run_service. For a page or a site, use cool_p |
cool_delete_comment | Delete one comment from a computer's page, whoever left it and in any state, as cool comments delete does; deleting one that is already gone changes nothing. Delete only when the owner asked you to; answer a comment with cool_resolve_comment instead. |
cool_delete_computer | Permanently delete an account-owned computer and its stored disk. |
cool_delete_file | Delete a file, or a folder and everything in it with recursive. On a computer with a VM it deletes from its disk; on a site without a VM it publishes a new live release without the file, as a publish does. Deleting never gives a computer a VM. |
cool_delete_secrets | Delete a whole secret set and its keys, as cool secrets delete does. Deleting a set that does not exist changes nothing. State pending means the computers' egress proxies still hold its proxy keys; that finishes automatically. |
cool_disconnect_integration | Disconnect a service; pending means it finishes automatically. |
cool_exec | Run one shell command on a computer with a VM, as cool exec does, and wait for it to finish: it returns its status, exit code and the last 16 KiB of its stdout and of its stderr (omitted_bytes counts what was left out; write long output to a file and read it with cool_read_file). A command still run |
cool_expose_port | Point the computer's HTTPS URL at one HTTP port without starting or stopping processes or changing sharing. Replaces the previous selected port. On a site served from its VM, the port answers every path but the site's functions (/api), and its files in /home/runtime/app are never served as files aga |
cool_get_computer | Return one of the account's computers, by its name or id. |
cool_get_computer_network | Return one computer's outbound network policy. |
cool_get_default_network | Return the account's default outbound network policy. |
cool_get_domain | Return the computer's custom domain: its hostname, state, what it waits for (detail), and the two DNS records the owner creates at their DNS provider. challenge waits for the TXT record, issuing for the CNAME, serving for the hostname to answer through Cool Computers; active serves what the computer |
cool_get_email_address | Return one computer's Cool Computers email address. |
cool_get_exposure | Return the selected HTTP port and website access setting. This is configuration, not application health. |
cool_get_integration_connect | Return an account-scoped connection attempt. |
cool_get_logs | Return the latest failures of an account-owned site's edge functions, newest first: when each happened, the request's method and path (never its query), the release, and the error the module raised (name, message and first stack frame). Use it when a request under /api/ answers "function failed". On |
cool_get_secret_metadata | Return one secret set's metadata without plaintext values. |
cool_get_service | Return the computer's service and its current state: status (starting, running, restarting, stopped, exited or failed), ready, restarts since it was last started, last_exit, and last_output, the program's last line while it is not ready. |
cool_get_service_logs | Return a bounded non-following tail of typed service stdout and stderr. |
cool_get_usage | Return the account's limits and defaults next to what it uses now: computers with a VM against the quota, memory, storage, and sites created in the last 24 hours. |
cool_give_vm | Give an existing site its own VM, in place, as cool vm does: an always-on Ubuntu machine with sudo, where cool_exec, cool_run_service and cool_write_files work. The site keeps its name and URL; its published files move to /home/runtime/app and keep serving until a program's port is exposed. It canno |
cool_leave_comment | Leave a comment on a computer's page for the owner, under your own name as an agent, the way a person does with the page's Comment button, for the owner, their team or an agent to act on: pinned to one element, or drawn as marks on elements. Name an element with a CSS selector the page's comment scr |
cool_list_computers | List this account's computers and their current states. |
cool_list_emails | List bounded summaries of the newest messages, newest first. Read the metadata part when a summary is truncated. |
cool_list_files | List one folder of a computer's files: on a site without a VM, its live published files, all under /home/runtime/app; on a computer with a VM, its disk. Entries come in name order, a page at a time: when eof is false, list again with offset next_offset. Reading never gives a computer a VM. |
cool_list_integrations | Return connected services and health without credentials. |
cool_list_network_denials | Return recent denied outbound requests for one computer. |
cool_list_releases | List a site's releases, newest first, as cool releases does: each one's number, state, whether it is live, its file count, bytes and when it was made. |
cool_list_secret_audit | Return a bounded secret metadata audit history without plaintext values. |
cool_list_secrets | Return secret-set names, key names, and delivery metadata without plaintext values. |
cool_list_shares | Show who can open a computer, as cool share list does: its visibility (public: anyone with its URL; private: the owner and the people listed) and everyone it is shared with, the owner first, each with access and state (pending until an invited person accepts). Change it with cool_share and cool_set_ |
cool_mkdir | Create a folder on a computer with a VM; with parents, its missing parent folders too, and then a folder that already exists is no error. A site without a VM has no folders of its own: publish files under the folder with cool_publish instead. |
cool_plan_switch_workspace | Return the exact read-only plan for a GitHub branch workspace. |
cool_promote_release | Make an earlier release of a site live again, as cool releases promote does: the way to roll back. Its number comes from cool_list_releases; the release that was live stays listed and can be promoted back. |
cool_publish | To show something, publish the files with cool_publish (instant, no VM). To keep a server running, use cool_run_service, which gives the computer its own VM. Publishes a website or browser app from files, served at the computer's URL. Without computer, creates a new computer for them, named by name, |
cool_pull_comments | List the oldest open comments on a computer's page, at most 10, written by the owner, by other people, each of whose messages names its writer by name and email in from, or by agents, named in from; with job_id, the open comments of that job, which the owner asked you to handle; a job sent to a loca |
cool_query_database | Run SQL against an account-owned site's database. Use sql with optional positional params for one statement, or statements for a transaction. This can change data. A site needs cool.json with database: true and functions, then a published release. Keep SELECT results small with LIMIT. |
cool_read_email | Read one bounded UTF-8 metadata, text, or HTML chunk. Start at offset zero, then continue with the returned version and next_offset until eof; restart at zero if the content changes. |
cool_read_file | Read one file of a computer, as cool_list_files sees them, of at most 2 MiB, in chunks of at most 32768 bytes. The result has content when the chunk is UTF-8 text, else content_base64, with the file's size, its version (the SHA-256 of the whole file), next_offset and eof. To read on, pass offset nex |
cool_remove_domain | Remove the computer's custom domain. The hostname stops serving within seconds; the computer's own address is unchanged. A computer without a domain answers removed too. |
cool_reopen_comment | Reopen a comment you resolved asked, as cool comments reopen does, so it is open again and pulled with the others; the thread records "Reopened by agent.". Pass the version cool_resolve_comment returned. A comment resolved done is finished: leave a new comment instead. |
cool_reply_comment | Add a message to a comment's thread without answering it, such as a word on progress or a message to a person taking part, shown under your name to everyone taking part. It keeps the comment's state and returns the comment's id and state, not its thread or version: pull the comments again and read i |
cool_reply_email | Reply to a stored email; Cool Computers resolves the recipient, subject, and thread. |
cool_resolve_comment | Answer one open comment on the comment itself, which everyone taking part sees: state done with a reply once you did what it asks, or asked with one short question when you need the owner's answer before you can act; only the owner answers a question. On a computer with a VM, a done answer lists in |
cool_restart_service | Restart the configured durable service on an account-owned computer without changing HTTP exposure. |
cool_run_service | Save and start the computer's one long-running program and keep it running: after a crash it starts again after 1 s, doubling up to 60 s, and the service counts the restarts. Running it again replaces the service. With port, it is ready once the port accepts connections, and the computer's URL reach |
cool_send_email | Send one outbound email from an account-owned computer mailbox. |
cool_set_computer_network | Set the outbound network policy for one account-owned computer. |
cool_set_computer_visibility | Make an account-owned computer public or private. |
cool_set_default_network | Set the outbound network policy inherited by newly created computers. |
cool_set_domain | Connect a subdomain the user controls, such as app.example.com (no apex, no wildcard; punycode for an internationalized name), to the computer. Give the user the two returned records to create at their DNS provider: the TXT record proves control of the hostname and must resolve within 72 hours, the |
cool_set_secrets | Store a secret set, as cool secrets set does: the keys a site's functions get as env when its cool.json names the set ("secrets": "<set>"), or a VM's programs get with cool secrets exec. It replaces the whole set: send every key it should keep, with its value. Values are stored encrypted and never r |
cool_share | Give a person use of a computer by their email address, or take it away: access can_use shares it, none stops sharing it with them. Sharing emails an invitation to someone this account has not shared with yet; state is pending until they accept, active once they can open it. Use it to let someone op |
cool_stat_file | Return one file or folder's type, size, mode and modification time, as cool_list_files sees them, without reading it. |
cool_stop_service | Stop the configured durable service without deleting its configuration or changing HTTP exposure. |
cool_switch_workspace | Create or reuse a computer and switch it to an authorized GitHub branch workspace. |
cool_unexpose_port | Remove the selected HTTP route without stopping programs or changing sharing. The URL then shows a page saying the computer serves nothing; a site whose port was exposed never serves its files again. |
cool_verify_integration | Check a connected service: test its connection with the service, record its health, and refresh its stored credential when the service asks for that. Reports any action needed to reconnect it. Running it again is safe. |
cool_whoami | Return the verified account owner for this conversation. |
cool_write_files | Write files on a computer with a VM, under /home/runtime, creating their folders; a file that exists is replaced. Files in /home/runtime/app are public at the computer's URL; restart its service with cool_restart_service when it should load them. A site without a VM takes no writes: publish its file |