A sandbox for every agent
Nevia's computers are isolated virtual machines to run code, install what you need and pick up later where you left off.
Infrastructure now starts from intent. Nevia is the new cloud for teams that build, run and scale production AI.
Today's clouds were built for humans setting up servers that run for years.No patch makes them right for AI.
Computers to run agents and apps, databases for their data, GPUs for inference.
Nevia’s default compute is a Firecracker microVM. Each microVM runs on a bare-metal host and is ready in milliseconds. Compute scales to zero when idle and scales up with demand.
Virtual machines for larger, long-running workloads are on the roadmap, with startup times measured in seconds.
| microVMs | Virtual machines | |
|---|---|---|
| What it is | A lightweight Firecracker virtual machine | A larger virtual machine with a fixed compute allocation |
| Best for | Apps with variable demand and workspaces that can sleep when idle | Always-on applications with steady demand |
| Startup time | Milliseconds | Seconds |
| Scale to zero | Yes | No |
| Scales with demand | Yes | No |
| Size | Up to 16 vCPUs | Up to 160 vCPUs |
| Status | Available | Roadmap |
Each workload runs in its own microVM with its own kernel, and workloads are isolated by hardware virtualisation rather than by shared-kernel containers. MicroVMs run directly on bare-metal hosts without an extra hypervisor layer. Your application runs inside the microVM and can be deployed from an OCI image.
Compute is separate from storage. A machine's data lives on a replicated volume in the region, not on its compute host. This lets the machine sleep, wake and branch without moving data.
Nevia's purpose-built orchestrator manages each microVM's lifecycle and enforces isolation between workloads. Every machine is isolated from its neighbours through hardware virtualisation, control traffic stays off the guest's network interface, and ingress and egress are governed by declarative rules.
Some workloads are not bursty, like always-on applications with steady demand or services you want sized once and left running. For these, we are building a virtual machine offering with a stable footprint. It runs on the same engine as microVMs, starts in seconds and supports the same branching capabilities.
Nevia offers two storage primitives: Block storage for data that needs speed and branching, together with S3-compatible object storage.
| Block storage | Object storage | |
|---|---|---|
| What it is | A block volume from a pool of SSDs, mounted as a disk | S3-compatible object storage |
| Best for | Working directories, databases, anything latency-sensitive | Files, artifacts, backups, large blobs |
Every VM gets a data disk that behaves like a local NVMe drive. Underneath, it is a volume backed by a pool of SSDs with built-in replication, connected to the VM over a high-speed private network. Compute and storage always sit in the same region to keep read and write latency low.
Copy-on-write is built into every volume. Snapshots and clones are metadata operations and a clone shares every block with its parent until one side writes.
Data is replicated across independent drives and spread across many storage nodes by default, with nothing to configure. After a failure, the system automatically rebuilds the affected replicas. Storage is separate from compute, so your data survives if a compute host fails or is replaced.
Use object storage for files, build artifacts, exports and large blobs that you write once and read many times. It is S3-compatible, so existing tools and SDKs work out of the box.
Every Nevia Computer and Database gets its own name, URI and ready-to-use endpoint secured with TLS. Private networking and egress controls are on the roadmap.
| Public endpoints | Private networking | |
|---|---|---|
| What it is | A DNS name and TLS endpoint per machine | Private connections between your Computers and Databases |
| Best for | Apps, APIs and databases reached from anywhere | Applications that communicate across Computers and Databases without public endpoints |
| Protocols | HTTPS (HTTP/1.1, HTTP/2), Postgres over TCP with TLS | — |
| Status | Available | Roadmap |
Each machine is named in DNS and reached through an ingress proxy on its host, which routes traffic to the destination VM. Computers get HTTPS URLs for the ports they publish, with TLS handled for you. Databases are reached via a standard Postgres TCP connection, with TLS passed straight through to the database instance.
We are building private connections between your workspace Computers and Databases, with default-deny egress with per-machine allowlists. You decide what each machine can reach.
Nevia's computers are isolated virtual machines to run code, install what you need and pick up later where you left off.
Nevia's databases start in an instant for any app or agent, branch for every test or migration and keep running as long as you need.
Nevia serves open-weight models through the API your apps and agents already use, right next to your computers and databases.
Integrations
SDK languages
Every agent your product starts can provision its computers and databases through API, CLI, MCP or the SDK. Most of them sit idle most of the time, so they sleep until the agent needs them again.
Run coding agents on full Linux machines in the cloud, and let them install the tools and dependencies they need. Copy configured environments to reuse them across sessions, and save checkpoints to restore your setup and continue where you left off.
Set up a computer in the state you want, checkpoint it, and restore that checkpoint for every rollout. Each run starts from the same memory and files.
Computers, databases and their branches stay in the region you create them in. Pick one in Europe and the data stays in Europe.
Agents that run for hours or wake once a day keep their memory and running programs while they sleep. They pick up where they stopped, with no restart.
Branch a computer and its database for each pull request and review the change against a copy of real data. Delete both when the pull request merges.
Agent-written code runs on a computer next to the Postgres database that holds the data. Point it at a branch and the original stays untouched.
Give each customer their own computer and database, each in its own microVM. Idle ones sleep, so customers who rarely log in don't keep machines running.
Branched app-db into app-db-1. It's a copy-on-write branch, so it was ready in seconds and app-db is untouched. Run the migration against app-db-1, and delete it if it goes wrong.

Nevia by Aiven is the cloud reimagined for agents and their humans. It gives you computers, which are full virtual machines, and Postgres databases, and both branch while they run and sleep when idle. Agents and people drive the same resources over MCP, the CLI, the API, the SDK or the console.
Nevia is in beta, and we're onboarding teams one by one before we open public access. and tell us about your use case.
Yes. Everything lives in shared workspaces, so your team and its agents work on the same computers and databases. Each person gets a role (admin, editor or viewer), and scripts, CI and agents sign in with private keys of their own. Workspaces covers the details.
Nevia runs on our own bare-metal servers in Europe, with US and APAC regions coming soon. Your computers and databases stay in the region you create them in. If you need it on your own infrastructure, the same stack runs in your cloud account or on-prem, so what you need.
Yes, and we'd love to talk. Open-weight inference is on its way into Nevia as a product, and until then we can set models up for your team. and we'll work out the setup with you.
Nevia is built by Aiven, the open source data platform for apps and AI agents in production, which runs PostgreSQL, Kafka, OpenSearch and more on AWS, Google Cloud and Azure. Its core team came from Flow AI, which Aiven acquired in 2026.