Dorky — sandboxes you can talk to

Dorky is your favorite agent's favorite server.

Each machine is an isolated microVM with its own filesystem, network, and public URL. It boots in milliseconds, holds state between calls, and costs nothing while it sleeps. It speaks the OpenAI responses format, so any tool that accepts a base URL can talk to a Dorky machine too.

Run the agent you already drive on one, and it gets:

A computer, for building and running software.
Memory, on disk and in conversation.
An address that users, webhooks, and services can reach.
Keys that open exactly what you allow, and nothing else.
Rails for payments and authorization, between users and agents.

Machines are cheap to make and free while asleep, so people cut one per project, per user, per customer, or per job: by command, by API, or by a wildcard DNS record on your own domain.

There's one waiting for you:

Create your key →

One passkey (no signup) opens an account with trial credit. From there you spin up your first machine and start chatting with it in the browser — top up when you want more. Prefer your own harness? Point it at the machine with dorky connect below.

Inference is metered how you choose: the trial credit to start, then your own plan, an API key, or pass-through you bill to your users — with spend and tracing in one place.

What it is

A machine is a real server: filesystem, processes, your agents, your services. In front of it stands exactly one door. The door checks every request against a key, asks the machine's own auth service to allow or deny, and writes the outcome down:

internet ──────key───▶ ┌──────────┐ verify ┌───────────┐ your backend ──key───▶ │ door │─────────▶│ authd │ your machines ─key───▶ │ │◀─────────│ allow/deny│ └────┬─────┘░░ └───────────┘░░ │ allowed & written down ┌─────────────┼─────────────┐ ▼ ▼ ▼ ┌─────────┐ ┌───────────┐ ┌─────────┐ │ agents │ │ services │ │ files │ └─────────┘░ └───────────┘░ └─────────┘░

Deny is the default. A fresh machine answers nobody but its owner:

$ curl https://swift.agents.dorky.host/anything 403 — this machine answers only its owner

Everything it ever does for anyone else is a key you cut on purpose. A key is a signed grant, scoped to a route, an agent, a use count, and a deadline — and your machine verifies it locally, no call home:

key share-9k2f grants POST /v1/responses · agent chef · 5 uses expires 2026-07-13 signed ed25519, by your machine — verified at the door, no call home

That's one auth model for everyone: your backend holds a key like any caller, and so do your other machines, your users, and their agents. The whole machine is declared in one small file, and what isn't written there is closed:

# Dorkyfile [agent.chef] instructions = "Plan meals from ./recipes. Be opinionated." tools = ["lookup", "reply"] [routes] "/recipes" = "public" # Everything else stays closed.

On the platforms you've probably looked at, an agent is a job that runs inside someone else's cloud, reachable only through your own app. A Dorky machine does it backwards: it's an address on the internet. Your app, webhooks, paying customers, and other people's agents can all call it directly — and it can belong to you, or to each of your users.

What it can do

Serve

RoutesOpen one path to a page, a file, or a service; everything else stays shut. ModelsThe machine's agents list in /v1/models, so anything that can talk to a model can use them.

Grant

KeysEach key grants one power. They expire, they revoke, and nobody needs an account to use one. WebhooksAn inbound event runs one turn, limited to the tools you listed for that hook. PricesCharge per job on any route; the invoice-and-budget flow is the whole checkout.

Sign off

BudgetsA hard cap on what any key can spend. Work under the cap runs; work over it waits for you. TapsConsequential actions pause until you approve them with a signed tap on your phone.

Machines

SleepA machine at rest costs nothing and forgets nothing; a call wakes it in about 200ms. ForkCopy a running machine, or spawn one per job; your machines find each other on their own. BuildThe machine's agent can write a new service and wire its route while everything keeps serving.

Anything ordinary — a rate limiter, a redirect, a cache — is one command too. Underneath, it's a whole server.

Plug it in

Your harness$ dorky connect pi (or claude, codex) Any OpenAI toolBase URL → https://swift.agents.dorky.host/v1 (Cursor, SDKs, curl — its agents list as models.) Your agentPoint its model endpoint at the machine, or park the whole agent on it.

Run it through us and the integration is already done: domain, wake and sleep, backups, payments, phone approvals, all pre-wired. Your first machine is free. Or run the same software on your own hardware or under your own domain.

FAQ

Who pays for the AI?

Whoever you decide. On your own machine, turns ride the subscription or API account you connect. On machines you ship to users, meter pass-through and bill it: every turn is counted, priced, and traced in one place, so the gateway, the billing, and the observability you used to wire separately come with the door. Dorky charges for hosting; self-hosting costs you nothing.

Can anyone on the internet talk to my machine?

No. A fresh machine answers only you. Every opening is one you made on purpose, and you can list them all with dorky exposures.

My friend doesn't have a Dorky account. Can they use my link?

Yes. The key carries its own permission, and your machine verifies it directly. Nobody has to sign up with us for your stuff to work.

What happens if Dorky-the-company disappears?

Your machine keeps running. It's open source, your data sits on your disk, and hosting can be re-pointed anywhere. The only part we operate is the hosting, and hosting is the easy part to replace.

Why is it called Dorky?

Door + key. Every machine is a door your agent lives behind, and every link, webhook, and permission is a key that opens exactly one thing. 🚪🔑

Links

GitHub · Docs · Discord · iPhone app · Pricing

d’ork’y, 2026