For Claude Code, Aider, OpenClaw, and browser agents

Run coding agents without letting them touch your laptop.

Start Claude Code, Aider, OpenClaw, Hermes, or browser-use in a clean Firecracker microVM with persistent storage, an embedded terminal, and its own HTTPS URL.

Isolated filesystemPersistent workspaceBYO model keyThrow away or restart anytime

Launch a clean agent VM See how it works

Why Gentity

Your development machine is becoming the agent sandbox.

Coding agents can run shell commands, install packages, edit repos, open browsers, and keep state. That is useful. It is also exactly why they deserve their own machine.

Local riskOne bad command can touch real files, volumes, or secrets.

Setup dragDocker, TLS, ports, volumes, browsers, and keys become your job.

Agent sprawlRunning several agents side by side turns into a pile of ad-hoc boxes.

Start with the agents you already use

OpenClaw

openclaw.ai

Hermes

Nous Research

Aider

aider.chat

Claude Code

anthropic.com

browser-use

browser-use.com

Product

Real agents. Real microVMs. Your screen.

One dashboard for the whole fleet. Click into any instance to land on its native UI with an embedded terminal — you never have to leave the tab.

Gentity dashboard listing five running agents (Claude Code, OpenClaw, Hermes, browser-use, Aider) each with status, agent type, model, and quick actions — Every agent. One dashboard.

OpenClaw chat UI embedded in the Gentity workspace, with a terminal pinned at the bottom — OpenClawChat assistant — control plane in one click

Hermes session manager above the HERMES-AGENT TUI in the embedded terminal — HermesTUI agent in your terminal, sessions in your browser

Aider pair-programmer chat with a connected git repo — AiderPair-programmer wired to a git repo

browser-use WebUI configuring an autonomous Chromium agent — browser-useDrive a real Chromium with AI

How it works

Three steps. A clean machine.

No Kubernetes. No VPS setup. No agent touching your local repo. Pick an agent, bring a model key, open its workspace.

// 01 — choose

Pick your agent

Browse the catalog of pre-built agent images. Want something custom? Bring your own Docker image.

// agent
openclaw, hermes, aider, ...

// 02 — configure

Bring your model

Connect any LLM provider with your own API key. OpenAI, Anthropic, DeepSeek, Google, OpenRouter, or local.

// model
claude-sonnet-4-5
// $ANTHROPIC_API_KEY

// 03 — launch

Open the URL

Each instance gets its own subdomain, its own volume, its own everything. Stop it, restart it, your state persists.

// endpoint
https://oc-x7k2m9
.gentity.ai

Features

Built for agents that can take action.

Not a generic container host. Gentity is shaped around agents that execute commands, keep state, expose UIs, and need a boundary.

// isolated microVM

One microVM per agent

Each agent gets a Firecracker microVM with an isolated kernel, private network, and dedicated disk. If the agent breaks something, it breaks its own workspace.

// bring your own key

Bring your own model

Use the model account you already pay for. We don't markup tokens or proxy prompts. Your API keys stay inside the agent environment.

// persistent volumes

State that survives restarts

Stop an agent to save cost, then resume tomorrow with files, packages, browser state, and working context still in place.

// per-instance subdomain

A real URL per agent

Every instance gets its own HTTPS endpoint with automatic TLS. Share it, embed it, hit it from another agent. It's a real address.

// catalog of agents

The agents developers actually use

Claude Code, OpenClaw, Hermes, Aider, browser-use, and more. Use a prebuilt image or bring your own Docker image.

// run-many, run-cheap

Run many in parallel

One agent on GPT-4o for hard problems, three more on DeepSeek for cheap throughput. Compare side by side. Throw the bad ones away.

CLI

Or skip the browser entirely.

Same primitives, terminal-native. One line to install, scriptable end to end, works from your laptop and from CI without changes.

// install — curl

$ curl -fsSL https://gentity.ai/install.sh | bash

✓ Installed gentity 0.0.2 to /usr/local/bin

// install — homebrew

$ brew install gentityapp/tap/gentity

macOS · Linux · arm64 · x86_64 · source on GitHub ↗

// spin up

$ gentity compute create --agent claude-code --model claude-sonnet-4-5

// list / inspect

$ gentity compute list

// jump in

$ gentity compute open cl-x7k2m9

// tear down

$ gentity compute delete cl-x7k2m9 --yes

Use any of these from a GitHub Action or a cron job — drop a token inGENTITY_TOKENand you're live.

Pricing

Pick the box that fits your agent.

Each plan is one isolated microVM. Monthly billing — no per-hour surprises, no seat fees, no model markup.

Mini// hobby

Webhooks, scripts, Aider on a small repo. Light agents only.

$15/mo≈ $0.021/hr

2 vCPU shared
2 GB RAM
10 GB volume
50 GB bandwidth
HTTPS subdomain + auto-TLS
7-day log retention

Launch Mini

Solo// bots

Discord/Slack bots, Claude Code on a project repo.

$33/mo≈ $0.045/hr

2 vCPU shared
4 GB RAM
50 GB volume
100 GB bandwidth
HTTPS subdomain + auto-TLS
7-day log retention

Launch Solo

Questions, answered.

Why not just run Claude Code or Aider locally?

Local is great until the agent can edit real files, run shell commands, install packages, touch databases, or burn time debugging your machine instead of your task. Gentity gives the agent a clean machine with its own filesystem, terminal, URL, and persistent disk, so your laptop stays out of the blast radius.

How is this different from running Docker on a VPS?

A VPS gives you one Linux box where you set up Docker, manage SSL, configure nginx, watch for OOMs, and patch the OS. Gentity Compute gives you a UI and an API where each agent is a real isolated microVM with its own filesystem and TLS — no kernel sharing, no shared disk, no OS maintenance. The provisioning model is closer to AWS Lambda than to a VPS, but with persistent state.

Can I bring my own agent? My own Docker image?

Yes. The catalog is a convenience layer — under the hood you can launch any Docker image (public or private), pass any environment variables, and mount any volume size. If your agent runs in a container, it runs on Gentity Compute.

What about my LLM API keys? Do you see them?

Your keys live inside your agent's environment variables, encrypted at rest with AES-256-GCM. We don't proxy your model calls, don't log prompts, and don't markup tokens. You pay your model provider directly.

Can agents talk to each other?

Each agent has its own URL — they can hit each other over HTTPS like any other API. MCP-based coordination (one agent orchestrating others) is fully supported. The current pricing model assumes independent agents; for tightly-coupled multi-agent topologies, get in touch.

Is there a CLI?

Yes. Install with either curl -fsSL https://gentity.ai/install.sh | bash or brew install gentityapp/tap/gentity. From there you can compute create, list, open, stop, restart, delete, logs --follow, and ssh — the same operations the dashboard exposes, scriptable from any shell or CI. Source is public on GitHub; binaries are Bun-compiled for macOS and Linux on both x86_64 and arm64.

Where does my data live?

Volumes are pinned to the region you create them in. Today we run in iad (US East). Each volume is encrypted at rest. We never read the contents.

What about Gentity Mail, Phone, Card?

Compute is the first of four primitives in the Gentity stack. Mail (email addresses an agent owns), Phone (real numbers an agent answers), and Card (payment credentials an agent can use) are in active design. We'll announce timelines when they're closer to ready.

Stop running powerful agents on your main machine.

Give each one a clean microVM, persistent disk, terminal, and URL.

Launch a clean agent VM $ install gentity

Part of a larger stack

Compute is the first of four primitives Gentity is building. The same way humans need a place to live, an address, a voice, and the means to transact — so do agents.

● Compute · liveMail · in designPhone · in designCard · in design