The complete guide to building a remote server for a personal AI agent that runs 24/7 for 20,000 won a month

To put the conclusion first: running a personal agent on your home PC is a choice that carries a triple burden of electricity, noise, and disconnection when you go out. The right answer is to put only a light agent core on a cheap virtual server costing 10,000-20,000 won a month, buy intelligence from an external cost-effective API, draw the approval line with Jev MCP, and daemonize it 24/7 with PM2. Follow the steps below and within an hour you will have your own unattended agent infrastructure.

1. Architecture: what runs where

The fatal mistake of the approach that puts a 30B-class model locally is that it burns all the server resources on intelligence computation. The key to remote operation is separation of roles.

In this structure the VPS does no reasoning, so no GPU is needed, and 2vCPU/4GB is enough.

2. Choosing a cheap server: options around 10,000-20,000 won a month

The reference spec is 2vCPU, 4GB RAM, 40GB SSD, Ubuntu 24.04 LTS. No GPU is needed.

Measured in the operator's environment; for always-on domestic use, the OpenCloud Micro VM has the best balance of latency and management convenience. If you are only testing, it is worth running Vultr hourly for a few days before deciding.

Initial access and firewall opening after creating the server:

ssh ubuntu@<server IP>
sudo apt update && sudo apt upgrade -y
sudo ufw allow 22/tcp
sudo ufw allow 8000/tcp
sudo ufw enable

3. Step 1: Set up the agent core environment

Install the Python-based Hermes agent core.

# Install base dependencies and the agent pipeline package
sudo apt update && sudo apt install -y python3-pip python3-venv git
git clone https://github.com/hermes-agent/hermes-agent
cd hermes-agent
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

4. Step 2: Match a cost-effective external API

The core of this guide is lowering the operating unit cost with an external API that does not consume server resources. The cost-effective API price list as of September 2026 is as follows.

Measured in the operator's environment; for a personal agent at around 100,000 tokens a day, it is about 1,000 won a month with DeepSeek. The API cost is overwhelmingly cheaper than the server cost (20,000 won), so what to save is not server specs but token leakage.

Isolate API keys as environment variables. Do not hardcode them in source code.

# Set API key environment variables
echo 'export DEEPSEEK_API_KEY="sk-ds-xxxxxxxxxxxxxxxx"' >> ~/.bashrc
echo 'export OPENROUTER_API_KEY="sk-or-v1-xxxxxxxxxxxxxxxx"' >> ~/.bashrc
source ~/.bashrc

5. Step 3: Bind the Jev MCP monitoring layer

An API-based agent can also go off the rails at any moment, just like a local one. So put a Jev MCP monitoring layer at the chokepoint of external calls.

# Install the Node.js runtime and the MCP bridge globally
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs
sudo npm install -g @modelcontextprotocol/server-bridge

Write the config file as follows.

{
  "agent": {
    "name": "Hermes-API-Production",
    "llm_provider": "deepseek",
    "model": "deepseek-chat",
    "api_key": "env:DEEPSEEK_API_KEY",
    "max_context_tokens": 128000
  },
  "mcp_servers": {
    "jev-loop-validator": {
      "command": "node",
      "args": ["/usr/local/lib/node_modules/@modelcontextprotocol/server-bridge/jev-entry.js"],
      "env": {
        "OPENROUTER_API_KEY": "env:OPENROUTER_API_KEY",
        "JEV_DECISION_THRESHOLD": "0.85"
      }
    }
  }
}

JEV_DECISION_THRESHOLD is Jev's approval threshold. 0.85 means risky actions such as file deletion or external transmission are blocked below 85% confidence. For personal use, 0.8-0.9 is recommended.

6. Step 4: 24/7 unattended operation with PM2 daemonization

# Install the PM2 infra and launch the Python agent daemon
sudo npm install -g pm2
pm2 start app.py --name "hermes-api-agent" --interpreter ./venv/bin/python3

# Set guardrails to auto-revive on VPS reboot
pm2 startup
pm2 save

You must run the command that pm2 startup prints, exactly as-is, once for auto-revive after reboot to work. Check status with pm2 status, and logs with pm2 logs hermes-api-agent.

7. Real-world risks and the triple fence

After running unattended for a week with this structure, three unexpected situations actually occurred.

1. Runaway infinite loops: the agent kept re-calling the same API hundreds of times, burning tokens
2. Excessive file access: it touched directories outside its work scope
3. Infinite retries on API failure: it papered over a provider failure with retries, increasing cost and load

The solution is to put a definitive code fence at the final gateway where execution permission leaves.

Fence 1: Token limiter (Python)

import time

class TokenRateLimiter:
    def __init__(self, max_tokens_per_hour=100000):
        self.max = max_tokens_per_hour
        self.used = 0
        self.reset_at = time.time() + 3600

    def consume(self, tokens):
        now = time.time()
        if now > self.reset_at:
            self.used, self.reset_at = 0, now + 3600
        if self.used + tokens > self.max:
            raise RuntimeError("Hourly token limit exceeded, agent paused")
        self.used += tokens

Fence 2: Jev interceptor rule

Risky actions (deletion, external transmission, payment) are unconditionally blocked if Jev's confidence is below 0.85, and the operator is notified. The threshold setting in the config.json above is exactly this.

Fence 3: Docker sandbox

docker run -d --name agent-sandbox \
  --memory=2g --cpus=1 \
  -v /home/ubuntu/agent-work:/work \
  --network=agent-net \
  python:3.12-slim sleep infinity

Isolate the agent's file operations so they only happen inside /work. It cannot touch the host system at all.

8. Monthly cost simulation

This is measured in the operator's environment. Compared with local GPU electricity (30,000+ won a month) it is half, and you can connect from your smartphone even while out to give instructions.

Conclusion

Putting a heavy local model on a remote virtual server is a mistake. The triangle of a cheap server, a cost-effective commercial API, and Jev MCP guardrails holds both cost-effectiveness and stability together. Even if you buy intelligence from outside, moving the approval line into a definitive code fence is the core of unattended operation.