OffshoreVps
Agents n8n · Ollama · Docker No KYC

AI agent hosting: a server that keeps your agents running 24/7

Agents and automations need a machine that is always on, has its own IP and does not sleep when your laptop does. Start on a VPS from $8.50 a month for agent frameworks that call hosted models, or move to a GPU server from $109.25 a month to run the model yourself. Full root, NVMe storage, pay in crypto.

BitcoinMoneroTether (USDT)USD CoinEthereumLitecoinSolanaBNB
No KYC Pay in crypto Full root Live in minutes 10 locations

Page by the OffshoreVps teamUpdated Prices read from the live catalogue

Servers

Pick the server that fits your agents

VPS prices are for Romania on a one-month term. A 12-month term takes 50% off. GPU prices are for Moldova.

Location
VPS

Agent starter

$8.50/mo

or $4.25/mo on a 12-month term (−50%)

  • CPU2 vCPU
  • RAM4 GB DDR4
  • Disk60 GB NVMe
  • NetworkUnlimited · 1 Gbps

One or two agents or workflows that call hosted model APIs, plus a small database.

Configure and order
Location
Popular
VPS

Agent workhorse

$13/mo

or $6.50/mo on a 12-month term (−50%)

  • CPU4 vCPU
  • RAM8 GB DDR4
  • Disk120 GB NVMe
  • NetworkUnlimited · 1 Gbps

n8n or a framework with Postgres, a vector store and a headless browser for web tasks.

Configure and order
Location
VPS

Small local models

$25.50/mo

or $12.75/mo on a 12-month term (−50%)

  • CPU8 vCPU
  • RAM32 GB DDR5
  • Disk200 GB NVMe
  • NetworkUnlimited · 1 Gbps

Small quantised models on CPU, slow but private, next to your agents.

Configure and order
Location
GPU

GPU: 1x RTX 4090, 24 GB

$109.25/mo

or $54.63/mo on a 12-month term (−50%)

  • GPU1x RTX 4090 · 24 GB
  • CPU12 vCPU
  • RAM64 GB DDR5
  • Disk1 TB NVMe

Run a model on the same server as the agent that uses it. Larger GPUs are on the GPU page.

Configure and order
What you can run

Things people put on an agent server

Workflow automation

n8n and similar tools: webhooks, schedules and integrations that run whether or not you are online.

Agent frameworks

LangGraph, CrewAI, AutoGen or your own Python and Node code, started by systemd and restarted if it fails.

Browser agents

Headless Chromium with Playwright for scraping, monitoring and form-filling tasks. Give it 8 GB of RAM.

Local models

Ollama or vLLM serving an open model, so prompts and documents stay on a server you rent.

MCP servers

Tools your assistant can call. See MCP server hosting for the details.

Bots and scheduled jobs

Telegram and Discord bots, trading bots and cron jobs that need to run all day.

Sizing

How much server an agent really needs

Most agents do very little work themselves. They send a prompt to a model, wait, then call a tool. If the model runs at a provider, the agent server only needs a few gigabytes of RAM and a steady connection, so the starter VPS is enough.

When you need more

  • A database or vector store next to the agent (Postgres, Qdrant, Chroma) wants 2 to 4 GB of RAM on top.
  • A headless browser uses 500 MB to 1 GB per open page. Plan 8 GB if several run at once.
  • A local model is a different job. The weights must fit in memory: roughly 2 bytes per parameter at 16-bit, 1 at 8-bit and 0.5 at 4-bit, plus about 20% extra. A GPU server runs this fast; CPU-only works for small models but slowly. The private LLM hosting page has a sizing table.

Keep agents contained

An agent can run code and call tools, so treat it like any untrusted process. Give it its own Linux user or container, a model API key with a spending cap, and only the file and network access it needs. Never put a wallet's spending key or an admin password in an agent's environment.

Setup guide

From order to a running agent in four steps

Order the server

Create an account, top up with crypto and deploy the size you picked. You get root access within minutes.

Prepare it

Update Ubuntu, create a user, open only the ports you need and install Docker.

Run your agent stack

Start n8n with Docker Compose, or run your own Python agent as a systemd service.

Add HTTPS and, if you want, a local model

Put Caddy in front for HTTPS and install Ollama on a GPU server.

Step 1

Prepare the server and install Docker

Commands assume Ubuntu 22.04 or 24.04 and a root login over SSH.

Log in, update, create a user, firewall
ssh root@YOUR_SERVER_IP

apt update && apt -y upgrade
adduser --disabled-password --gecos "" agent

ufw allow OpenSSH
ufw allow 80/tcp
ufw allow 443/tcp
ufw enable
Install Docker
curl -fsSL https://get.docker.com | sh
usermod -aG docker agent
systemctl enable --now docker
Step 2, option A

Run n8n with Docker Compose

n8n listens only on localhost here. Caddy (step 3) adds HTTPS in front of it. Replace agents.example.com with a domain that points at your server. Check the n8n hosting docs for the current options.

/home/agent/n8n/docker-compose.yml
services:
  n8n:
    image: docker.n8n.io/n8nio/n8n
    restart: unless-stopped
    ports:
      - "127.0.0.1:5678:5678"
    environment:
      - N8N_HOST=agents.example.com
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://agents.example.com/
      - GENERIC_TIMEZONE=UTC
    volumes:
      - n8n_data:/home/node/.n8n

volumes:
  n8n_data:
Start it
su - agent
cd ~/n8n
docker compose up -d
docker compose logs -f     # Ctrl+C to stop watching
Step 2, option B

Run your own Python agent as a service

A systemd unit starts the agent at boot and restarts it if it crashes. Secrets live in a file only the agent user can read.

Set up a virtual environment
su - agent
mkdir -p ~/app && cd ~/app
python3 -m venv venv
./venv/bin/pip install requests      # add your framework: langgraph, crewai, autogen...
nano agent.py                       # your agent code
nano .env                           # API_KEY=...   (then: chmod 600 .env)
exit
/etc/systemd/system/agent.service
[Unit]
Description=My AI agent
After=network-online.target
Wants=network-online.target

[Service]
User=agent
WorkingDirectory=/home/agent/app
EnvironmentFile=/home/agent/app/.env
ExecStart=/home/agent/app/venv/bin/python agent.py
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
Start it and read the logs
systemctl daemon-reload
systemctl enable --now agent
journalctl -u agent -f      # Ctrl+C to stop watching
Step 3

Add HTTPS with Caddy

Caddy gets and renews a certificate by itself once your domain points at the server. Webhooks and web interfaces then work over HTTPS.

Install Caddy and proxy to n8n
apt -y install caddy
cat > /etc/caddy/Caddyfile <<'EOF'
agents.example.com {
    reverse_proxy 127.0.0.1:5678
}
EOF
systemctl reload caddy
Step 4, GPU servers

Run a local model with Ollama

Ollama serves a model on localhost, and your agent calls it instead of a hosted API. Pick a model that fits the GPU memory (see the sizing table).

Install and test a model
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1:8b

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Say hello in five words.",
  "stream": false
}'
Keep it private
# Ollama listens on 127.0.0.1:11434 by default. Leave it that way.
# If an agent on another server needs it, tunnel over SSH instead of opening the port:
ssh -N -L 11434:127.0.0.1:11434 agent@YOUR_SERVER_IP
Good to know

Where this setup shines and where to be careful

A good fit when

  • You want agents and workflows that run all day without your computer
  • You want your own IP, your own logs and full control of the software
  • You want prompts and data on a server you rent, with a local model
  • You want to pay in crypto without handing over ID

Be careful when

  • You give an agent a key that can spend money or delete data
  • You expose a web interface or the Ollama port to the internet without a login
  • You run untrusted code from a model on the host instead of in a container
  • You skip a spending cap on your model API key
FAQ

AI agent hosting questions

01What is AI agent hosting?

A server that runs your AI agents, automations and bots around the clock. You rent a VPS or GPU server with root access, install your agent software and leave it running.

02Which agent software can I run?

Anything that runs on Linux: n8n, LangGraph, CrewAI, AutoGen, Flowise, Open WebUI, your own Python or Node code, and MCP servers. You have full root, so Docker works too.

03Do I need a GPU?

Only to run the model yourself. If your agents call a hosted model API, a VPS is enough. A GPU server makes sense for local open models like Llama, Mistral or Qwen, or when prompts must not leave your server.

04How much RAM do I need?

4 GB for a framework that calls hosted models, 8 GB with a database or a headless browser, and 32 GB or a GPU for local models. You can move to a bigger plan later.

05Can I run a browser agent?

Yes. Headless Chromium with Playwright works on a VPS. Plan about 500 MB to 1 GB of RAM per open page and give the server 8 GB if several run at once.

06Do I need KYC to host an agent?

No. You create an account with a generated login, top up with crypto and deploy. See no-KYC VPS hosting. You stay responsible for what your agents do, under our terms.

07How is it paid?

From your account balance, topped up with Bitcoin, Monero, Ethereum, Litecoin, Solana, TRON, BNB, USDC or USDT. Longer terms take up to 50% off. See pricing.

Sources

Where these numbers come from

Checked 20 October 2026. Chain sizes and software requirements change, so confirm against the source before you order.

Put your agents on a server of their own

Pick a size, pay in crypto, log in as root. No ID, no card.