Quick start

End state in about 10 minutes: an AI agent running in your editor, building a real app on a server you control, with a public URL anyone can open.

What you need

• A machine with Docker to run your apps (your "server"). Your own laptop works to start; for something that stays up after you close the lid, a cheap cloud box is better — see Getting a server just below.
• A free account on app.agentry.run — sign in with Google or GitHub.
• An API key for at least one AI provider — Anthropic, OpenAI, OpenRouter (recommended: one key, every major model), or any open-weights provider. Why?
• A harness — pick one of: Claude Code, Cursor, Roo Code, Continue.dev, or any MCP client.

Getting a server

Anything that runs Docker works. In rough order of "cheapest and easiest":

• Your own laptop — free, and fine for trying agentry out. The catch: your apps only stay online while the laptop is awake and connected. Good for learning, not for something you want to share reliably.
• A small cloud box — a few dollars a month gets you a machine that stays up 24/7. Good first picks:
  • Hetzner Cloud — the best value. A CX22 (2 vCPU / 4 GB) is about €4–5/month and comfortably runs several apps. Pick the Ubuntu 24.04 image.
  • DigitalOcean — a $6/month Droplet (1 GB) for a single small app, or $12 (2 GB) for breathing room.
  • Vultr and Linode/Akamai are similar, also in the ~$5–6/month range.
  • Any AWS / GCP / Azure Linux VM works too if you already use one (an t3.small/e2-small or larger).

When in doubt: a Hetzner CX22 with Ubuntu is the cheapest path to a reliable, always-on setup. More detail and provider notes in Add a server.

You need Docker on that machine

agentry runs inside a Docker container, so the machine needs Docker installed and running.

• A cloud Linux box: follow Docker's official install steps for your distro — Install Docker Engine. On Ubuntu, the convenience script is the one-liner option.
• Your Mac or Windows laptop: install Docker Desktop (on Windows, enable the WSL2 backend).

Confirm it works with docker run hello-world before continuing.

1. Install the CLI

In a terminal:

curl -fsSL https://agentry.run/install.sh | sh

This installs the agentry command. Confirm it's on your path:

agentry --version

If the command isn't found, re-open your terminal (the installer adds its directory to your $PATH).

2. Sign in

agentry login

This opens app.agentry.run in your browser, walks you through sign-in, and saves a token under ~/.agentry/.

3. Connect a server

A server is any machine that runs your sandboxes and apps — your laptop, a Hetzner box, an EC2 instance, anything with Docker.

Open app.agentry.run/clusters → Add this machine. The panel shows a one-line command. Copy it, paste it on the machine you want to use, and press enter.

That command:

• Pulls the agentry runtime image (~500 MB, one-time)
• Starts a small runtime container that dials out to bridge.agentry.run
• Registers a unique cryptographic identity for this machine

When it finishes, refresh the dashboard — your server appears with a green connected dot.

No inbound ports required

Your machine dials out to agentry. It never opens an inbound port. No firewall rules, no DNS, no certificates to manage.

4. Wire up your harness

Pick your harness and follow the matching guide — each is a 30-second copy-paste:

• Claude Code
• Cursor
• Roo Code
• Continue.dev
• Other / generic MCP client

Restart the harness when you're done. The agentry tools should now appear in its tool list.

5. Build your first app

In your harness, prompt the agent:

Use agentry to build me a simple hello-world homepage — a clean single page with a heading and a short intro. Start the dev server so I can preview it.

Always open with "Use agentry"

That phrase tells the harness to reach for the agentry tools instead of writing files into your local folder. Skip it and most harnesses will just scaffold code locally — no sandbox, no server, no shareable URL.

The agent will:

1. Create a sandbox on your server — a clean, isolated workspace.
2. Scaffold the project, write the code, install dependencies, and start a dev server inside the sandbox.

When it's done it tells you the port the dev server is listening on — not a clickable link. The agent can't open a sandbox to the internet; that's an operator action you take in the dashboard (next step). Sandboxes don't publish ports until you ask.

6. Preview what was built

Open app.agentry.run/sandboxes, click your sandbox, pick the listening port the agent reported, and click Share. agentry returns a *.agentry.live preview URL backed by the live dev server.

When you create the share, choose who can open it:

• Org (default) — anyone signed in to your agentry organization. Best for sharing with teammates.
• Public — anyone with the link, no sign-in. Best for quick external feedback.
• Password — anyone with the link who enters a password you set.

The preview tracks the sandbox: as the agent makes changes and the dev server reloads, the URL reflects them. It's for looking, not for production traffic — that's what deploying is for.

Want the code on your laptop?

agentry pull <sandbox-id> downloads the sandbox's project to a local folder (skipping node_modules and other build junk). Handy for committing to your own git repo.

7. Ship it

When the preview looks right, go to app.agentry.run/sandboxes, click the sandbox, and click Deploy.

agentry will:

1. Check the app builds cleanly — a broken build is rejected here, before anything goes live.
2. Package it into a production container image — your stack is detected automatically (Next.js, Vite, Python, Go, and more).
3. Save that image to your registry, if you've connected one — this is what lets you roll back later.
4. Run the container on your server and hand back a stable public URL like:

my-app-3f7e2a1c.agentry.live

Share that URL — your app is live, on your own server.

What just happened

• The agent worked inside a sandbox on your server — files, dependencies, the dev server, all of it. Nothing landed in your local checkout.
• Your AI key drove the build. agentry never proxies the model or sees your tokens.
• The preview and the deploy URL both flow through the agentry bridge — an encrypted tunnel your server opened. Your server never accepted an inbound connection.
• The deploy produced a reusable image. Ship a change and you get a new image; if it misbehaves, you can roll back to the previous one in a couple of clicks.

Is this safe?

Short answer: your code and data never leave machines you control, and nothing in agentry is trusted by default.

• Your stuff stays on your server. The agent's files, your app's database, your secrets — all on the machine you connected. agentry is the front door, not the host. Turn agentry off and your apps are still sitting on your server.
• Nothing is exposed. Your server dials out to agentry and never opens an inbound port — there's nothing on it for the internet to find or scan.
• Your AI key is yours alone. It lives in your harness. agentry never sees it.
• Zero trust, literally. Every machine — your laptop, your server — gets its own cryptographic identity, and every request between the pieces is verified and checked against your account before it's allowed through. No component trusts another just because it's "inside"; nothing is assumed, everything is proven. Lose a laptop and you revoke just that one identity; the rest keep working.

That's the one-minute version. The full picture — what's encrypted, what we can and can't see, how multi-tenant isolation is enforced — is in the security model.

What's next

• Concepts — five minutes on how the pieces fit together.
• Prompting that works — patterns that produce shippable apps on the first try.
• Add a database — wire Postgres or MongoDB into every app you build.
• Custom domains — serve from app.yourcompany.com instead of *.agentry.live.