oi.
Agent-native static hosting

Instant web hosting for agents

Tell your agent to publish. It gets back a live URL at {slug}.oi.mrdk.io — no account, no build step, no waiting.

Read the quick start

Free and anonymous. Sites last 24 hours unless you claim them — claiming is free too.

1

Your agent publishes

Three HTTP calls: declare the files, upload them, finalize. The skill or llms.txt teaches any agent the flow.

2

The URL is already live

Finalize returns siteUrl. Open it, share it, or hand back the claimUrl to keep it forever.

Start in one paste

Give this to any agent that can make HTTP requests. Nothing to install, nothing to sign up for.

prompt
Publish this folder to oi (oi.mrdk.io) and give me the URL.

Read https://oi.mrdk.io/llms.txt first, then:
1. POST https://oi.mrdk.io/api/v1/publish with a JSON manifest of every file's path and size.
2. PUT each file to the presigned upload URL that came back for it.
3. POST the returned finalizeUrl with the versionId to go live.

No account is needed. Hand me the siteUrl, and the claimUrl too so I can keep the site past 24 hours.

Prefer to install the skill so it is always available? One command, then ask for a publish in plain language:

shell
npx skills add oimrdk/skill --skill oi -g

Nothing to install if you would rather not: the prompt above works on its own, and so does telling the agent to read llms.txt.

The agents it works with

The coding agents and agentic editors oi is built to be driven by. None of them ships an oi integration, we have no arrangement with any of them, and none is needed — every one of them can run a shell command or make an HTTP request, which is the whole requirement.

Antigravity OpenClaw Claude Code Codex Cursor Hermes Kilo Code Cline Pi opencode

What differs between them is only how the instructions get in front of the model. There are three routes, and all three end at the same three API calls.

It loads skills from disk

Several of the tools above read a folder of installed skills from disk. One command puts oi's manual and its helper scripts there, globally with -g or pinned to a single repository without it.

npx skills add oimrdk/skill --skill oi -g

It has its own installer

Some tools install skills through their own command rather than a shared folder. Hermes is the one in this list that does, and it takes the skill repository path directly.

hermes skills install oimrdk/skill/hermes/productivity/oi

It has neither

Then install nothing. Paste the prompt above, or tell the agent to read llms.txt and follow it — the same publish, discovered at the moment it is needed instead of ahead of time. A shell with curl is enough on its own.

How a publish works

Three calls, and the Site is not live until the last one succeeds — so an agent can build the manifest, stream the bytes, and hand back a URL inside a single turn.

POST /api/v1/publish

Create

Send a manifest of paths and sizes. oi returns the slug, the live siteUrl, a presigned upload URL per file, the finalizeUrl, and — for anonymous Sites — the one-time claimToken.

PUT <upload url>

Upload

Send each file straight to its own signed URL on the storage origin. Files whose hash matches a previous version are skipped and copied server-side instead.

POST <finalizeUrl>

Finalize

The version becomes live at once. A byte-identical republish is a no-op that answers unchanged: true and leaves the live version alone.

share

Hand it over

Give the user the siteUrl, and the claimUrl as well if the Site is anonymous — that link is what turns 24 hours into forever.

the whole thing, in curl
# 1. create — declare the files
curl -sS https://oi.mrdk.io/api/v1/publish \
  -H "content-type: application/json" \
  -d '{ "files": [ { "path": "index.html", "size": 1234 } ] }'

# 2. upload — PUT each file to the URL that came back for it
curl -X PUT "<upload url>" --data-binary @index.html

# 3. finalize — the Site goes live
curl -sS -X POST "<finalizeUrl>" \
  -H "content-type: application/json" \
  -d '{ "versionId": "<versionId>" }'

What that URL serves is decided by what you uploaded: a root index.html is the page, a single file gets a rich auto-viewer, a folder with no index gets a browsable listing, and an app that routes in the browser turns on SPA fallback — the serving rules, in order.

What happens after the URL exists

Publishing is the first thirty seconds. The rest is the same API and the same agent, later — arranged here by the question you are actually holding when you reach for it, each one handing off to the part of the docs that carries the detail.

Who can open it

Pick the audience, then the address

A new Site is a public link with an unguessable slug — right for something you are about to send to one person. When it is not, the same Site takes a shared password or an invite-only allowlist of addresses and email domains, enforced on the server before a byte is read, on every path rather than the front page only.

The address, though, is not a choice here: every Site answers at its own {slug} subdomain and nowhere else. Custom domains, team workspaces and public profiles are part of the oi API contract and are not implemented on this deployment — the domain endpoints in particular cannot be, because this deployment cannot issue a certificate for a hostname it learns about at publish time.

When it changes

Republish without holding your breath

Every publish is an immutable version, and restoring one is instant — a pointer flip, not a re-upload — so a bad deploy is a thirty-second problem. It is included for every account here; there is no tier to buy first.

Sending it again is cheap on purpose: include a hash per file and oi skips what it already has, uploading only what changed and copying the rest server-side at finalize. A byte-identical republish does no work at all and says so.

When static is not enough

Let the page do a little more

Site Data gives a page with no backend a validated, access-checked place to keep records — a form’s submissions, a poll’s votes, a shared list — declared in a .oi/data.json manifest and called from ordinary browser JavaScript. Drives are the other half: private folders for the agent rather than the visitor, with versioned writes and scoped tokens for handing one folder to another agent.

What this deployment does not run is equally worth knowing before you build on it: no proxy routes, no analytics, no public profiles, no workspaces, and no custom domains. Availability lists every API operation this deployment answers and every one it does not, and the API says the same thing at the moment of failure: a contract operation with no route behind it returns 404 with details.reason: operation_not_available_on_deployment, not a vague "check the docs".

Ten things worth a URL

Not a feature list. A list of the situations where a link turns out to be shorter than the explanation — which is most of them, once an agent can make one without asking.

  • 01Four hundred photos from a shoot as a browsable folder with a password on it, sent to exactly one client — and no account on a gallery service anybody has to sign up for.
  • 02The bug you just reproduced on one page: the screenshot, the tail of the log, and the diff. Rather than four attachments and a paragraph explaining what order to open them in.
  • 03A long job's progress as a status board the agent republishes every couple of minutes while it works. Only the bytes that changed go up, so doing it often costs almost nothing.
  • 04Somebody's CV rebuilt in an afternoon and put on a domain they already own, with the certificate handled the moment the DNS resolves.
  • 05The internal service nobody documented written up from its own source and restricted to your email domain, so the team can read it and the open web cannot.
  • 06Three design directions side by side at one link, so the person who has to choose can choose from their phone instead of downloading a zip.
  • 07An invitation with the details sent as one link instead of a screenshot in a group chat, restricted to the addresses you actually invited.
  • 08A board game a nine-year-old invented with its rules at a URL short enough to read out loud across a table.
  • 09A dashboard you regenerate nightly republished over the same URL each time, with every earlier night still in version history if today's numbers look wrong.
  • 10Something half-finished you will never open again which is fine. Publish it anonymously, do not claim it, and in twenty-four hours it deletes itself.

Pricing

Start with no account at all. An account is free too, and it is what makes Sites permanent and adds version history and access control. There is no paid tier — see the pricing page for the full table and for what this deployment does not offer.

Anonymous$0

No sign-up. Share and forget.

  • No account needed
  • 24-hour expiry, claimable
  • 25 MB max file
  • 60 publishes / hour

Both tiers are free — this deployment sells nothing, and Site Data and Drives are included rather than gated. Custom domains, analytics, public profiles and team workspaces are part of the oi API contract and are not implemented here; see what runs on this deployment.

Frequently asked

Including the two questions everyone asks before trusting a host: who can see my files, and where do they live.

What is oi?

oi is web hosting an agent can drive on its own. You give it a file or a folder; it gives back a URL that is already live. There is no build step, no server to keep running, and no dashboard you have to visit first.

It exists because the last step of agent work — show me the thing you made — used to need a human. Now the agent finishes the job.

Which agents and tools does this work with?

All of them, in the sense that matters: if it can run a shell command or make an HTTP request, it can publish to oi. There is no plugin to wait for, and no vendor has to ship an integration first.

Install the hosted skill with npx skills add oimrdk/skill --skill oi -g and the agent learns the whole surface, or just point it at /llms.txt and let it read.

Do I need an account to create a site?

No. Anonymous publishing needs no sign-up at all: create, upload, finalize, and the URL is live.

Twenty-four hours later that site is deleted — the files, not just the listing — by a sweeper that runs every minute against the deadline. The URL then answers 410 Gone rather than pretending it never existed, so an agent can tell an expired link from a wrong one.

The create response includes a one-time claim link. Follow it with an account and the expiry never arrives — the same site, same URL, now permanent.

Are accounts free?

Yes, and it is the only account tier here — nothing on this deployment is sold. An account makes Sites permanent and adds version history, rollback, password and invite-only access, and up to 50 API keys.

The wider oi API contract describes paid tiers, and gates Site Data and Drives behind them. Here both are included and nothing can be charged for at all. What this deployment does not implement — custom domains, analytics, public profiles, team workspaces — is listed on the pricing page and, operation by operation, in the docs.

Where do my files actually live?

On oi's own infrastructure and nowhere else. Uploads go to the oi storage origin over signed, single-use URLs; the bytes land in content-addressed blob storage, identical files stored once; and a request to {slug}.oi.mrdk.io is answered by oi reading those same blobs back. No third-party content delivery network sits in front of your Sites, no external object store holds a copy, and no other provider is in the path.

The trade-off, since you will notice it eventually: one origin rather than edge locations everywhere, so how far you are from it is how fast the first byte arrives — and if it is down, Sites are down. That is what the status page is for, and it reports what the running process can actually verify rather than what someone remembered to update.

Are oi sites public or private?

You choose, per Site. The default is a public link with an unguessable slug. You can add a password, or restrict a Site to specific verified email addresses and email domains.

Access is enforced by the server before a single byte of a gated Site is read, so a private Site cannot be reached by guessing a path or skipping the front page.

Can I use my own domain name?

Not on this deployment. Every Site is served at its {slug} subdomain and nothing else.

The reason is specific rather than a shrug: a custom domain needs a TLS certificate issued for that exact hostname, and the proxy in front of this deployment can only answer HTTP-01 challenges for names it already knows. Connecting one would silently serve a certificate error, so the four domain endpoints answer 404 instead of pretending.

Can I use oi with a team?

Not as shared accounts — workspaces are part of the oi API contract and are not implemented on this deployment. Every API key acts on exactly one personal account.

What does work for a team: share a Site with named people using invite-only access, which verifies each address by email before serving a single byte, and issue a separate API key per agent or tool so any one of them can be revoked alone.

Can I connect my sites to third-party services?

Site Data gives a static page validated, access-controlled record storage it can call straight from its own JavaScript — enough for forms, polls, feedback, and shared lists — declared in a .oi/data.json manifest.

What this deployment does not have is proxy routes, the contract feature that forwards a Site path to an upstream API with the credential held server-side. A .oi/proxy.json file publishes as an ordinary static file and is never interpreted, so do not ship a key in one expecting it to be hidden.

Why is publishing so fast?

Because nothing is built. A publish is a manifest, direct uploads, and a pointer flip — the version goes live the moment finalize returns.

Republishing is faster still: send a hash per file and oi skips everything it already has, copying those server-side instead of re-uploading. A byte-identical republish does no work at all and tells you so.

Can I host anything?

Anything static, within the file-size limit: a generated site or app, a report, a slide deck, a data visualization, a PDF, an image gallery, a prototype, a game, a single document you want a link for.

What you cannot do is run code on the server — a backend, a long-running process, a general-purpose database. Sites are files, plus Site Data for records a page needs to keep.

What you may not publish is set out in the acceptable use section: no malware, phishing, spam networks, harassment, or material that exploits minors. Reports go to the abuse page.

I'm an agent — what should I do first?

Read /llms.txt for the short version or /llms-full.txt for the whole context, then create a Site with POST /api/v1/publish. The OpenAPI spec describes every endpoint and /skill.md is the operating manual.

If you prefer structured discovery, start at /.well-known/agent.json or the RFC 9727 catalog.

Give your agent a URL to hand back

Publish anonymously in the next minute, or make an account and keep everything.

Most recently: The install commands we print actually install — the changelog has the rest.