The cloud for agents
to deploy and run containers
Your agent just built a website, an API, or a dashboard, and it only runs on your machine. On Cloudish the agent signs itself up, ships it as a container that keeps 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.
Tell Claude, Codex, or Grok:
No credit card. New keys start with a small free credit grant. Agent reading this page: the full API reference lives at /skill.md.
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 keeps it running: Express, FastAPI, WebSockets, workers, MCP servers. 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 idle scale-downs 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.
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 subdomain
Opt in and your app gets its own origin and a managed TLS certificate, for anything that assumes it is running at the root of a domain.
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.
From nothing to a running container in three calls
Get a key
One unauthenticated call, no signup form and no email verification loop, so an agent can do this on its own.
Deploy
Send a build context or an image reference to /api/v1/projects. That single call creates the project, starts the build, and once it succeeds, the app is live at its own https:// URL.
Claim it
Hand the human a link. They sign in once, and the credits land on the same key the agent is already using. Nothing to re-configure.
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.
Your agent just built something on localhost. Now what?
Whoever you want to show it to can't open your laptop. Tell your agent to deploy it to Cloudish and get back a link anyone can open. No AWS console, no credit card, nothing to sign up for first. Claim that link once and you land in a real dashboard: every project's status, build history, and logs, plus a slider that shows exactly what your credits are worth.
- Say "deploy this to Cloudish" and the agent does the rest
- Claim the link and get a dashboard: status, builds, and live logs
- Free credits to start, nothing to enter a card number for
Claim the link and this is waiting for you: status, builds, and logs, no CLI required. Most people never need it; the agent already did the deploying.
Deploy this to cloudish.ai and give me the live URL.Paste that back into whatever you built it in (Claude Code, Codex, Cursor) once the skill above is installed.
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 micro: billed for 0.1 vCPU / 0.2GB, using up to 0.5 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 | CPU | Memory | Per hour | Always on, per month | 1 hour a day, per month |
|---|---|---|---|---|---|
micro | 0.5 | 1 GB | $0.0107 | $7.84 | $0.41 |
small | 0.5 | 1 GB | $0.0297 | $21.66 | $1.13 |
medium | 1 | 2 GB | $0.0533 | $38.93 | $2.03 |
large | 2 | 4 GB | $0.1007 | $73.48 | $3.83 |
micro ranges from 0.1 to 0.5 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 0.5 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 idle app scales to zero after 15 minutes. 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 micro | 0.5 | 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 micro ranges from 0.1 to 0.5 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 micro'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, a Dockerfile, and a prepaid key. 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. Render and Fly are the same answer for a human who wants a container.
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 / 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 platform team, through a console, IAM, and billing setup |
| Unit | Any Dockerfile or image, long-running, optional disk | A git repo and a framework (Vercel runs containers only per request), or a container a human sets up | Anything, once someone wires the infra |
| Money | Prepaid on the key, hard cap, parent keys fund child keys | A card on a team account, 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 still live there | 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.
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