VPS Sizing Guide for Self-Hosted AI Agents in 2026

The answer depends on one question before any spec number: is your agent calling an external API (OpenAI, Claude, Gemini) or running the model locally? When the agent uses external APIs, the VPS handles orchestration only — a lightweight process that needs surprisingly little hardware. A Contabo Cloud VPS 4 (4 vCPU / 8 GB RAM / NVMe) is the comfortable production baseline for most API-driven setups, including multi-agent orchestration platforms like Paperclip with up to 20 concurrent agents. Local LLM inference changes everything, and requires a separate tier of hardware.

AI Agent VPS Specs at a Glance: Tier Table

The table below covers the five main self-hosted agent workloads, from a single API-driven agent to local LLM inference. All figures reflect the production-comfortable baseline, not the absolute minimum.

The Rule That Governs Everything: API vs Local Inference

When an agent calls OpenAI, Claude, Gemini, or a similar external API, the VPS runs only the orchestration layer: a Node.js or Python process, a Postgres or SQLite database, some HTTP routing, and possibly a few Docker containers for agent sandboxes. The heavy compute — the actual language model inference — happens on the API provider’s GPU cluster, not on your server. The result is that an API-driven agent is surprisingly lightweight to host.

Running a local LLM (via Ollama, vLLM, or llama.cpp) changes this entirely. The VPS becomes the inference server, and RAM requirements jump from single-digit gigabytes to 16–64 GB depending on the model size. Most self-hosted agent deployments in 2026 are API-driven — understanding this split is the most important step before sizing any server.

API-Driven Agents: Paperclip, Hermes, n8n, CrewAI

For the majority of self-hosted agent setups in 2026, the VPS is running: an orchestration process (Node.js for Paperclip, Python for CrewAI/LangGraph, or a workflow engine like n8n), a Postgres or SQLite database for state and audit logs, a web dashboard, and optionally Docker containers providing isolated sandboxes per agent.

Paperclip’s own documentation lists a minimum of 1 vCPU and 1–2 GB RAM, with 2 vCPU and 2 GB as sufficient to get started. The production-comfortable baseline — handling ~20 concurrent agents with PostgreSQL, Docker sandboxes, and an active web dashboard — is 4 vCPU and 8 GB RAM. Hermes Agent has an even lower minimum: 1 vCPU and 1 GB RAM when routing all inference to external APIs. Adding n8n as a workflow automation layer alongside agents adds approximately 512 MB to 1 GB of RAM overhead but keeps the total within the 8 GB tier for most workloads. Contabo’s Cloud VPS 4 (4 vCPU / 8 GB / NVMe SSD) covers all of these configurations with comfortable headroom.

Browser Automation Adds Significant RAM: Playwright and Selenium Stacks

One of the most common causes of spec underestimation in AI agent deployments is underestimating how much RAM browser automation consumes. When an agent autonomously browses the web — doing lead research, scraping pages, filling forms, or running Playwright-based workflows — each headless Chromium instance uses 1–2 GB of RAM on its own. An agent stack that starts comfortably within 8 GB can exceed that limit quickly once browser automation enters the picture.

The practical minimum for a browser-automation agent stack is 16 GB of RAM: 8 GB for the orchestration layer, database, and application overhead, plus 4–8 GB reserved for concurrent browser instances. Contabo’s Cloud VPS 6 (8 vCPU / 16 GB) is the right tier for any agent setup that includes Playwright, Selenium, or similar web automation tooling.

RAG Pipelines and Vector Databases

Retrieval-augmented generation (RAG) — connecting agents to a vector database so they can search a private knowledge base before responding — adds RAM and storage requirements on top of the base orchestration spec.

Qdrant, ChromaDB, and Weaviate are the most common vector stores in self-hosted agent stacks. A mid-size collection (100,000–1 million vectors) typically requires 2–4 GB of additional RAM and 50–100 GB of extra storage for the index and embeddings. A full RAG stack — agents plus vector database plus embedding pipeline — is comfortable at 16 GB RAM and 200 GB NVMe. Note: the embedding generation step (running the embedding model itself) adds further load; using an external embedding API (OpenAI, Voyage AI, Cohere) avoids this cost at the price of sending document text to a third party.

Local LLM Inference: When You Stop Sending Data to External APIs

Running a language model locally — most commonly via Ollama — is the right choice when data privacy is the primary concern: sensitive customer data, regulated industries, or compliance requirements that prevent data from leaving your infrastructure. It is also the choice when per-token API costs become significant at scale.

One important nuance: if data privacy is the reason for self-hosting but you don’t need local inference, hosting an API-driven agent on a Contabo VPS in the EU Hub (Lauterbourg) keeps your orchestration layer, agent state, and customer data within EU infrastructure under German-owned hosting — even if the LLM calls go to Anthropic or OpenAI. This is a meaningful GDPR data-residency position that doesn’t require local inference and doesn’t require a 32 GB server.

Mapping Each Tier to a Contabo Product

All Contabo plans include unlimited traffic with no egress billing — relevant for agent workloads that pull data from the web, stream API responses, or push large volumes of orchestration logs. Verify current pricing and exact specs at contabo.com before provisioning, as product names and specs update over time.