Generally available

Isolated runtimes for AI agents.

Spin up any agent — OpenClaw, Hermes, Aider, OpenHands — on its own microVM. Bring your model, attach a volume, get a subdomain. Production-ready in seconds.

Launch your first agent See how it works

Works 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. Eight seconds.

No Kubernetes. No Dockerfiles. No cold-start magic to learn. Pick an agent, pick a model, click run.

// 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 the agent-native era.

Not a generic container host. Every primitive is shaped around how AI agents actually run.

// isolated microVM

True isolation, not containers

Each agent gets its own Firecracker microVM. A runaway loop in one agent can't touch any other. No shared kernel, no noisy neighbors.

// bring your own key

Bring your own model

Use the model you already pay for. We don't markup tokens, don't proxy your requests, don't see your prompts. Your keys, your control.

// persistent volumes

State that survives

Stop an agent to save cost, resume it tomorrow with full memory intact. Conversation history, work files, everything where you left it.

// 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 you actually use

OpenClaw, Hermes, Aider, OpenHands, browser-use, Cline. All pre-configured. 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

Webhook listeners, tiny bots, hello-world agents.

$7/mo≈ $0.0097/hr

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

Launch Mini

Solo// bots

Discord bots, Slack bots, lightweight production agents.

$19/mo≈ $0.026/hr

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

Launch Solo

Questions, answered.

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.

Give your agent a place to live.

First instance takes 8 seconds. Pay only while it runs.

Launch your first agent $ 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