Why agentry
Most "AI app builders" run your app on their servers, hold your data in their database, and bill you per app. agentry flips that around: the AI builds and ships real apps onto hardware you own. Here's why that matters.
You own it
Everything that matters lives on a machine you control:
- The code the AI writes.
- The data your apps store.
- The apps themselves, running as plain containers.
agentry is the front door — the thing that gives your app a URL and an encrypted path in — not the landlord. There's no lock-in: turn agentry off and your apps are still sitting on your server, your data still in your database. You can pick up the whole thing and move it, because it never left your hands in the first place.
You stay in control
You decide the parts that platforms usually decide for you:
- Your server. A laptop, a $5 cloud box, or a beefy machine in your own rack. Scale it up or down on your terms.
- Your model. Use Claude, GPT, Gemini, or an open-weights model — and switch any time without re-wiring. Prototype on something cheap, ship the hard parts on a frontier model. (Bring your own model.)
- Your shipping cadence. The AI builds and tests; you press Deploy. Nothing goes live until you say so.
No surprise platform limits, no "you've hit your plan's app cap," no waiting on someone else's roadmap.
Internal apps, without exposing internal data
This is where agentry shines for teams. A huge amount of useful software is internal — dashboards over a production database, admin panels, tools that touch customer records, scripts that read from systems behind your firewall.
With a typical hosted builder, putting an internal tool online means handing your data — or a tunnel to it — to a third party. With agentry:
- The app runs on your own server, right next to the data it needs. Your database connection never leaves your network.
- Outbound-only: your server opens no inbound ports, so there's nothing exposed to scan or attack.
- Lock it down with one setting — make a deployment org-only so only your team can open it, or add real user logins.
You get the convenience of "the AI built me a tool and it's at a URL" without the part where your internal data takes a trip through someone else's cloud. (More on the model: security.)
The economics work in your favor
Two costs, and agentry keeps both small.
One server hosts many apps
Hosting is a flat cost you pay once and share across everything you build. A single small server runs many sandboxes and deployed apps at the same time:
| Server | Approx. cost | Comfortably runs |
|---|---|---|
| Hetzner CX22 (2 vCPU / 4 GB) | ~$5 / month | several small apps + live sandboxes |
| Hetzner CX32 (4 vCPU / 8 GB) | ~$10 / month | a dozen-plus apps |
The number that matters: this is per server, not per app. Ten apps on one CX22 is still ~$5/month. Compare that to per-app hosting platforms, where each app — and often each add-on like a database — adds another monthly line item. Build twenty internal tools on agentry and your hosting bill doesn't move.
AI tokens, paid at cost
The only variable cost is the AI itself — and you pay your provider directly, at their price. agentry never resells tokens or adds a markup. Because you choose the model, you choose the price point.
Rough per-million-token rates (input / output), to show the range — always check the provider for current numbers:
| Model | Provider | ~Input | ~Output | Good for |
|---|---|---|---|---|
| DeepSeek V3 | DeepSeek | ~$0.30 | ~$1.10 | cheap, high-volume iteration |
| Gemini Flash | ~$0.15 | ~$0.60 | fast, low-cost drafts | |
| Claude Haiku | Anthropic | ~$1 | ~$5 | quick edits, cheap loops |
| Claude Sonnet | Anthropic | ~$3 | ~$15 | the best all-rounder for building |
| GPT (frontier tier) | OpenAI | ~$2–5 | ~$10–15 | strong reasoning |
| Claude Opus | Anthropic | ~$15 | ~$75 | the hardest problems |
One key for all of the above: point your harness at OpenRouter and you get every model behind a single key and bill, switchable with a one-line config change.
Putting it together
Say you build and iterate on a small internal tool over a week or two. Agentic coding is token-heavy (the AI reads a lot of context), so a real build might run somewhere in the 10–30 million tokens range, depending on how much you build. Ballpark for that work:
- On a cheap model (DeepSeek / Gemini Flash): a few dollars.
- On Claude Sonnet (the sweet spot for most building): roughly $30–100.
- On Claude Opus for the whole thing: more like $150–400 — which is why most people prototype cheap and only reach for Opus on the gnarly parts.
Add the flat ~$5 server — which is also hosting every other app you've built — and that's the whole bill. No per-app fees, no token markup, no plan tiers.
Two easy ways to spend less
Pick the model for the job — draft on a cheap one, switch to a frontier model only when you're stuck. And prompt caching (built into the major providers) makes the AI re-reading the same project context far cheaper across a long session.
When agentry might not fit
In the spirit of being straight with you: agentry is for people who want to run apps on their own hardware. If you specifically want a fully-managed platform that owns the servers, the autoscaling, and the on-call, a traditional PaaS may suit you better. And regulated workloads that need formal compliance signoffs and dedicated infrastructure are better served by a platform built specifically for that.
Next
- Quick start — a live app on your server in about 10 minutes.
- Concepts — how the pieces fit together.
- Security model — what's on your side, what's on ours.