The Cloud for Agents
Your AI agent built a website, an API, or a dashboard, but it's not online. Cloudish is where agents deploy and run containers: the agent signs itself up, puts it online and keeps it running, with a disk if it needs one, and pays from a prepaid key it can never overspend. No human in the loop until you want one.
Already built something? Say “Deploy this to cloudish.ai” in that chat. Or start in Claude Code, Codex, or Cursor.
No credit card. New keys start with a small free credit grant. Agent reading this page: the full API reference lives at /skill.md.
Not a developer? You don't need to be.
Cloudish puts what your AI builds on the internet. You don't need to know what a server or a container is: your AI does. Say "Deploy this to cloudish.ai" in the chat where you made it, and you get back a link anyone can open, even with your laptop closed.
- ChatGPT: add the Cloudish plugin once, then ask.
- Claude: just ask. When it asks to reach cloudish.ai, allow it.
- Claude Code, Codex, Cursor: just ask, in your project's folder.
- Free credits to start: no credit card, nothing to sign up for
Your AI also hands you a link to claim what it deployed: sign in once to keep your projects, see their status, builds and logs, and add credits.
Nothing built yet? Try it now
Pick one or type your own: your AI builds it, Cloudish runs it.
Build me a project tracker for my team, then deploy it to cloudish.ai
In ChatGPT, add the Cloudish plugin first. The prompt is copied too.
From a prompt to a live link in three steps
Tell your agent
Say "deploy this to cloudish.ai" in Claude Code, Codex, Cursor, or whatever built it. The agent gets a key of its own with one unauthenticated POST /api/v1/keys: no signup form, no email verification loop, no card.
It deploys
The agent sends a build context or an image reference to /api/v1/projects. That single call creates the project and starts the build, and once it succeeds, the app is live at its own https:// URL.
You get a link
The agent hands you the live URL, plus a claim link if you want a dashboard or more credits. Sign in once, and the credits land on the same key the agent is already using. Nothing to re-configure.
Tested against DigitalOcean, Render and Vercel
Claude Code built five apps from a spec, from a static site to a realtime chat, and deployed each one to all four clouds. An independent verifier then tested every live deployment.
The others needed 2 to 3, such as signing up, creating an API token and adding a payment method
Every required check passed on every app
The others took 3m 46s to 4m 54s
All five apps at a few visits a week. Busy, $39: in line with DigitalOcean and Render
Our own benchmark, open source and reproducible: one run on 13 Oct 2026, one trial per app, with Claude Code (Opus 5.5). Methodology and every result, including where the others score higher →
Everything a container needs, nothing you have to run yourself
No Kubernetes YAML, no registry to host, no reverse proxy to configure by hand.
The agent signs itself up
One unauthenticated POST /keys and the agent has a key of its own. No browser, no OAuth, no team to pick, no "ask the human before pushing." A human can claim it later; the agent never has to wait for one.
Any container, long-running
POST a Dockerfile or point at an image you already have. Cloudish builds it server-side and runs it: Express, FastAPI, WebSockets, workers, MCP servers. Each app is always on, or sleeps when idle and wakes on the next request, as you choose. No function timeouts, no framework preset, no local Docker daemon. If the build fails, the log says why, not just that it did.
SQLite is a feature, not an apology
Opt into a persistent volume per project and write to local disk like it is a normal machine, because it is. Restarts, redeploys, and sleeping never touch it.
Prepaid, like a gift card
Credits are bought upfront and metered by the second. Your agent can never spend past the balance on its key, no card on file, no surprise invoice at the end of the month.
A hard stop at zero
When a key runs out, new builds and deploys get a 402, its running containers stop within a minute, and its volumes wait for it. A child key spends only what it was sent, and the key above it can cap how much crosses that line.
Status you can poll
A build triggers automatically once your context uploads; the container app registers itself the moment the image is ready. Poll one endpoint for building, running, or failed, no scraping the subdomain to find out.
Secrets, encrypted
Per-project environment secrets, encrypted at rest, injected at runtime, never returned by any listing call.
A real domain, or your own
Every app gets its own subdomain with a managed TLS certificate, for anything that assumes it is running at the root of a domain. Bring your own too: add it by API, verify one DNS record, and the certificate issues itself.
Sign in with Cloudish
A standard OpenID Connect provider, backed by real Auth0 login. Point any OIDC-capable app at it and get per-user sign-in with no identity provider of your own to run.
A dashboard, after the fact
The skill and the API are the product; the dashboard is optional. Claim the link and land in a real UI: every project’s status, build history, and live logs, plus credit transfers. You’re not left reading JSON.
Agents can fund other agents
Any key can mint new keys for free and transfer credits to them with one call. A parent agent can create sub-agents, bankroll each one, and let them deploy or bill each other, no human account, no shared login.
Give your agent a skill, not a manual
Drop this into Claude (or any agent that reads Anthropic-style Skills) and it knows how to get a key, build from source, attach storage, and hand you a link to claim the credits, without you writing any of that glue yourself.
- Self-documenting: the skill file is generated from the live API
- No Docker daemon required on the agent's own machine
- The agent's key keeps working after a human claims it. Nothing rotates
- Credits transfer key to key, so one agent can create and fund others
curl -s https://www.cloudish.ai/skill.md -o ~/.claude/skills/cloudish/SKILL.mdPrefer to read it first? View the raw SKILL.md. Or skip the skill: it's two plain HTTP calls.
One prompt builds and deploys a system that builds apps
Plenty of tools turn a prompt into an app. Cloudish lets an agent like Claude Code build and deploy the tool itself from a single prompt, with no one stepping in: a service where anyone’s prompt gets its own Claude Code, in its own sandbox, on its own capped budget, and comes back a live app. That’s just one of the systems your agent could build this way.
Build a system on Cloudish that turns a prompt into a live web app, built by Claude Code in a sandbox of its own. A public app takes the prompts. A private runner app’s image runs Claude Code, locked down by a managed policy and an egress allowlist, and every prompt gets a fresh replica of it, deleted afterwards. For each prompt, mint a child key, fund it with 0.5 credits and hand it to the sandbox to deploy with. The sandbox reaches Claude through a proxy on the public app, with a token that dies with the run, never the Anthropic key. Read https://cloudish.ai/skill.md first. Deploy to cloudish.ai.
That’s about all it takes: give it to Claude Code with a Cloudish key and you get the bones of the system below. The rest of the demo is presentation.
demo.cloudish.appA public app takes the prompts
An ordinary Cloudish project. It holds the system’s two secrets: its Cloudish key and an Anthropic key.
Every prompt gets its own sandbox
A fresh replica of a private app that runs Claude Code, locked down by a managed policy and an egress allowlist, and deleted when the run ends.
Every app gets its own capped key
A child key with 0.5 credits, behind a daily limit. Claude Code deploys with it, so each app pays for its own build and container, and can never spend more than it was given.
Claude, without the key
Claude Code reaches Claude through a proxy on the public app, with a token that dies with the run. The Anthropic key never enters a sandbox.
Real keys, real credits, real containers. Pick an app, watch the run that built it, every command and API call shown, and open the app it shipped.
Pay for compute, not for tiers
Credits are prepaid, like a gift card. Your agent can't spend past the balance on its key, so there's no invoice waiting at the end of the month. Drag the slider to see what your credits are actually worth, computed live from the same rates the platform bills against.
Container sized as shared: billed for 0.1 vCPU / 0.2GB, using up to 1 vCPU / 1GB when spare. Rates come straight from the live API.
Every size, what it costs, and what it costs elsewhere
One credit is one US dollar and every price below already includes our margin. Next to it, the cheapest comparable option at each alternative, including the ones that beat us on price.
Every Cloudish size
| Size | Fully reserved | CPU | Memory | Per hour | Always on, per month | 1 hour a day, per month |
|---|---|---|---|---|---|---|
shared | No | 1 | 1 GB | $0.0107 | $7.84 | $0.41 |
small | Yes | 0.5 | 1 GB | $0.0297 | $21.66 | $1.13 |
medium | Yes | 1 | 2 GB | $0.0533 | $38.93 | $2.03 |
large | Yes | 2 | 4 GB | $0.1007 | $73.48 | $3.83 |
shared ranges from 0.1 to 1 CPU and from 0.2 to 1 GB of memory: it is billed for, and always has, 0.1 CPU and 0.2 GB, and uses up to 1 CPU and 1 GB whenever the machine it runs on has them spare. When the machine is busy it runs on its reserved 0.1 CPU, and if it's using more than 0.2 GB when memory runs short it can be restarted. Every other size is fully reserved. Billed per second, only while the container runs: an always-on app around the clock, any other until it sleeps, 15 minutes without requests unless it chooses its own time. Persistent volumes are not billed. Full details in instances.md.
The cheapest option at each provider
| Option | CPU | Memory | Always on, per month | 1 hour a day, per month |
|---|---|---|---|---|
| Cloudish shared | 1 | 1 GB | $7.84 | $0.41 |
| Vercel Pro plan, container images (Beta) | 1 | 2 GB | $20.00 | $20.00 |
| AWS Fargate, smallest task | 0.25 | 0.5 GB | $12.66 | $12.66 |
| OVHcloud VPS-1 | 2 | 4 GB | $4.54 | $4.54 |
| Render Starter web service | 0.5 | 0.5 GB | $7.00 | $7.00 |
| Railway Hobby plan | 0.5 | 1 GB | $20.26 | $5.00 |
| Fly.io shared-cpu-1x | 1 | 1 GB | $5.77 | $0.43 |
Cloudish shared ranges from 0.1 to 1 vCPU and from 0.2 to 1 GB of memory, as above. List prices in US regions from each provider's own pricing page, checked September 2026, before free tiers; OVHcloud's is its advertised starting price. "1 hour a day" is an app that gets traffic about an hour a day, left to each provider's own idle behavior: Cloudish, Vercel, and Fly.io scale to zero on their own, Railway does once you turn on its Serverless setting, and the rest cost the same either way. Railway bills what the app actually uses, so one that stays well under 0.5 vCPU and 1 GB costs less, down to its $5 minimum. Fly.io's CPU is shared, like shared's, and a stopped Fly Machine still pays about $0.15 a month to store a 1 GB image. Vercel's $20 Pro plan includes $20 of usage, which covers its memory ($15.48 for 2 GB busy all month); CPU is billed on top at $0.128 per active CPU-hour. OVHcloud is a virtual machine, the rest run containers; a VM is cheaper for something that runs all month and that you are happy to administer yourself, and comes with its own disk. Vercel has no disk, Fargate needs EFS billed separately, Render, Railway, and Fly.io bill disk per GB, and Cloudish doesn't bill it. Cloudish is also the only one here an agent can sign up for on its own.
Vercel is the cloud a team deploys Next.js to. Cloudish is the cloud an agent deploys a container to.
Vercel assumes a person, a git repo, and a framework. Cloudish assumes an agent and a Dockerfile. The agent mints its own key, and can never spend past its balance. They are not substitutes, so here is when not to use us.
Use Vercel if
A human is iterating on a Next.js app with preview deploys on every push, and a team is going to click through a dashboard.
Use Railway if
A human wants a long-running container with a volume, and is happy to sign up in a browser, link a repo, and put a card on file. It runs what we run; the difference is who operates it. Render and Fly are the same answer.
Use Cloudish if
The operator is Claude, Codex, or Grok, and what it built is a process, an optional disk, and a URL: an Express or FastAPI server, a SQLite-backed app, a WebSocket service, a worker, an MCP server. Something that has to keep running.
What each one assumes
| Cloudish | Vercel | Railway / Render / Fly | AWS / GCP | |
|---|---|---|---|---|
| Operator | An agent, signed up with one unauthenticated API call | A human, through a browser and a git provider login | A human, through a browser signup, GitHub, and a card | A platform team, through a console, IAM, and billing setup |
| Identity | API keys; a parent key creates child keys and funds them | Human team seats | Human team seats | IAM users and roles someone sets up |
| Unit | Any Dockerfile or image, long-running, optional disk | A git repo and a framework; containers only per request, no disk | A long-running container or repo, with volumes | Anything, once someone wires the infra |
| Money | A prepaid balance on the key; the agent can't spend past it | A card on a team account, billed after usage | A card on file, billed after usage | A billing account, billed after usage, no cap |
| Surface | skill.md and the API; the dashboard is optional | The dashboard; domains and env vars live there | The dashboard and CLI | The console |
Datacenters you can actually see
Today, do.cloudish.ai is the only datacenter live in production, running in New York. A second, in Seattle, is in testing. Each datacenter answers directly at its own subdomain instead of hiding behind an opaque region code, so an agent always knows exactly where its container runs and can target a specific one on purpose. A platform this small, containers, a registry, a ledger, and nothing else, is also fast to stand up again elsewhere. More cities are next, continents follow, then orbit stops being a joke.
What agents and their humans ask first
Do I need to know how to code, or what Docker is?
No. Tell the AI that built your app to deploy it to cloudish.ai: Claude, Claude Code, Codex, Cursor, or ChatGPT with the Cloudish plugin added. The agent gets a key of its own, packages the app with a Dockerfile, deploys it and hands you back a live URL. You only sign in if you want the dashboard or to add credits, through the claim link the agent gives you.
Can I get a surprise bill?
No. Credits are prepaid, like a gift card: one credit is one US dollar, there is no card on file and no invoice after the fact. New keys start with 0.1 credits, subject to availability. When the credits run out, new builds and deploys stop, running apps are stopped within a minute, and data on a volume is kept. Add credits and the app starts again on its next request.
Can an agent deploy with no human in the loop?
Yes, start to finish. One unauthenticated POST https://cloudish.ai/api/v1/keys returns a key of its own, with 0.1 credits to start, subject to availability. One POST /api/v1/projects with a Dockerfile build context or an image builds it server-side and keeps it running at its own URL; the agent polls one endpoint for the build status. There is no browser, signup form, card, or approval step anywhere on that path. A human can claim the key later for a dashboard, but nothing requires one.
Can I run production apps on Cloudish?
Yes. Cloudish is not only for prototypes: an app is a long-running container, and each deploy chooses whether it is always on or sleeps when idle. Sleeping is cheap for a demo: an app that chose neither sleeps after 15 minutes without requests and wakes on the next one. For production, set three things. Deploy it with "alwaysOn": true so it never sleeps and starts as soon as it is deployed, or choose Always on on its page in the dashboard. Pick the small size or larger (cpuCores 0.5 and memoryGb 1, or more): those are fully reserved and never restarted to make room for other apps, unlike the default shared size. And keep the key funded: every deploy and credits response shows its runway, and https://cloudish.ai/instances.md lists what each size costs always on. Add a volume for data and your own domain as needed. If you need HIPAA or other compliance requirements, talk to us through Help at https://www.cloudish.ai/help before you deploy.
How is spend capped, and what happens when a key reaches zero?
Credits are prepaid on the key, one credit is one US dollar, and they are metered by the second while a container runs. There is no card on file and no invoice after the fact. When a key reaches zero, new builds and deploys answer 402, requests to its apps answer 402 instead of starting a container, and its running containers are stopped within a minute. Volumes are kept. Add credits with a claim link or a transfer from another key, and the app starts again: an always-on app right away, any other on its next request. A child key spends only what it was sent, and the key above it can cap how much crosses that boundary in any time window.
Does my data survive restarts and redeploys?
With a volume, yes. Opt into a persistent volume of 1, 5 or 20 GB per project, mounted at /data by default. It survives restarts, redeploys, sleep and running out of credits, and only goes away when the project is deleted. There is no managed Postgres or MySQL: SQLite on the volume is the usual answer, or run Postgres inside the container with its data directory on the volume. A volume attaches to one container, so an app with one runs a single instance.
Can I use my own domain?
Yes. Every app gets its own https://<name>.cloudish.app/ subdomain with a managed TLS certificate, and can also answer at any number of domains you control. Add one with POST /api/v1/projects/{alias}/{app}/domains, add the TXT record it returns at your DNS provider, and point the domain at the datacenter with a CNAME (or an A record for an apex). The certificate issues automatically once both are in place. Each active domain costs 0.01 credits a day. The full flow is in https://cloudish.ai/skill.md.
Should I use a tunnel or deploy?
A tunnel shows localhost to someone else for as long as your machine and the tunnel stay up, which is right for a few minutes of preview. Deploy when the app should keep running without your laptop: Cloudish builds it on the server, gives it a permanent URL, keeps its files on a volume and its secrets encrypted, and keeps it always on or lets it sleep when idle and wake on the next request, as you choose.
When should I not use Cloudish?
Use Vercel if a human is iterating on a Next.js app with preview deploys on every push. Use Railway, Render or Fly if a human wants a long-running container with a volume and is happy to sign up in a browser and put a card on file; they run what Cloudish runs, the difference is who operates it. Use AWS or GCP if a platform team is wiring production infrastructure. Use Cloudish if the operator is Claude, Codex, Grok or another coding agent, and the artifact is a process, an optional disk and a URL.
Get your first container running today
Free to start. Paste this into Claude: a SQLite-backed app that writes to its own disk, exactly the workload a serverless platform can't keep running.
Build a beautiful todo app, SQLite-backed, drag-to-reorder, confetti on completion, then give me the URL by deploying to cloudish.ai