Architect production control planes for AI agents and RAG workers using REST (/api/v1), Streamable HTTP MCP (/api/mcp/v1), ephemeral SSH leases, and pgvector.
Production AI infrastructure management requires solving two tightly coupled distributed-systems problems at once: operating resilient compute, secret, vector, and object-storage planes for autonomous AI workloads, and exposing deterministic, least-privilege APIs so tool-calling agents can manage infrastructure without turning a model hallucination into a fleet-wide outage. Granting an LLM agent an unrestricted root SSH key and raw shell execution across production hosts collapses every security boundary in your architecture—a single indirect prompt injection inside a scraped log line or GitHub issue can exfiltrate environment credentials or drop stateful volumes.
Engineering a trustworthy AI control plane means enforcing a hard architectural boundary between probabilistic reasoning (the frontier LLM deciding what outcome is needed) and deterministic execution (schema-validated APIs, short-lived cryptographic leases, KMS secret hydration, and append-only audit trails). Note an explicit hardware design choice upfront: Servers Are Up builds high-IPC Intel Xeon CPU orchestration planes, KMS vaults, multi-model pgvector databases, and cloud storage designed for autonomous agents, RAG pipelines, and MCP tool servers calling hosted frontier LLM APIs—we do not sell GPU virtual machines.
Classical AIOps treated machine learning as a passive anomaly detector bolted onto metrics dashboards. Modern agentic infrastructure operations invert that flow: background SRE, CI/CD, and customer-onboarding agents actively inspect telemetry, provision isolated sandboxes, rotate configuration files, and verify HTTP health probes. Keeping those loops safe in production requires four non-negotiable invariants:
sau_exec_instance, sau_write_instance_file, POST /api/v1/instances) validated against strict schemas and Idempotency-Key headers rather than concatenating untrusted text into bash strings.id_ed25519 private keys on disk. Host access uses short-lived cryptographic leases (60–3600 seconds) that self-expire at the platform layer./api/v1) and Streamable HTTP MCP (/api/mcp/v1)To support both deterministic workflow engines (Temporal, GitHub Actions, OpenTofu) and tool-calling LLM agents (Claude Code, LangGraph supervisors, internal incident responders) without maintaining fragile glue code, Servers Are Up exposes its entire infrastructure graph across two native control planes backed by identical RBAC scopes and audit logs:
/api/v1): Resource-oriented HTTPS endpoints covering VM and container lifecycle, VPC firewall rules, guest file atomic writes, non-interactive command execution, ephemeral SSH lease issuance, and metrics retrieval./api/mcp/v1): Exposes 129 typed sau_* tools directly over standard HTTPS + Server-Sent Events (SSE) streaming. Because the MCP endpoint runs remotely at https://serversareup.com/api/mcp/v1, cloud-hosted background agents and multi-developer teams connect with a scoped Bearer Personal Access Token (sau_...)—eliminating local Node/Python stdio subprocess sprawl on laptops.Connecting an autonomous orchestrator or IDE agent to the Streamable HTTP MCP control plane takes a single declarative configuration block:
{
"mcpServers": {
"serversareup-ops": {
"type": "http",
"url": "https://serversareup.com/api/mcp/v1",
"headers": {
"Authorization": "Bearer ${SAU_OPS_READWRITE_PAT}"
}
}
}
}
sau_ssh_authorizeStatic SSH keys represent the single largest lateral-movement liability in automated server fleets. Once a keypair is injected into ~/.ssh/authorized_keys across twenty worker VMs, revoking access after a compromised CI runner or leaked agent workspace requires touching every host manually.
Servers Are Up replaces static keys with ephemeral SSH key leasing (POST /api/v1/instances/{id}/ssh-leases or the sau_ssh_authorize MCP tool). When an agent or deployment worker needs interactive tunnel or rsync access, it generates an in-memory Ed25519 keypair, requests a 300-second authorization lease against a target instance ID, performs its task, and discards the private key from RAM while the platform automatically purges the public key upon TTL expiry:
// scripts/ephemeral-diagnostic-run.mts
import { generateKeyPairSync } from "node:crypto";
const MCP_ENDPOINT = "https://serversareup.com/api/mcp/v1";
const SAU_PAT = process.env.SAU_OPS_PAT!;
async function callMcpTool(name: string, args: Record<string, unknown>) {
const res = await fetch(MCP_ENDPOINT, {
method: "POST",
headers: {
Authorization: `Bearer ${SAU_PAT}`,
"Content-Type": "application/json",
Accept: "application/json, text/event-stream",
},
body: JSON.stringify({
jsonrpc: "2.0",
id: `call-${Date.now()}`,
method: "tools/call",
params: { name, arguments: args },
}),
});
if (!res.ok) throw new Error(`MCP ${name} failed: HTTP ${res.status}`);
return res.json();
}
export async function inspectWorkerWithLease(instanceId: string) {
// 1. Generate single-use Ed25519 keypair strictly in process memory
const { publicKey } = generateKeyPairSync("ed25519", {
publicKeyEncoding: { type: "spki", format: "pem" },
privateKeyEncoding: { type: "pkcs8", format: "pem" },
});
// 2. Lease access for 300 seconds via sau_ssh_authorize (auto-revoked on expiry)
await callMcpTool("sau_ssh_authorize", {
instanceId,
publicKey: publicKey.trim(),
ttlSeconds: 300,
linuxUser: "ubuntu",
});
// 3. Or run non-interactive diagnostics directly without opening TCP/22 publicly
return callMcpTool("sau_exec_instance", {
instanceId,
command: "systemctl is-active agent-worker && df -h /var/lib/docker",
timeoutSeconds: 30,
});
}
For routine file updates and health checks, sau_write_instance_file and sau_exec_instance operate over the host control channel without requiring TCP port 22 to be exposed on a public IPv4 interface at all.
Autonomous agents and RAG workers routinely hold high-privilege third-party credentials: Anthropic/OpenAI/Gemini API keys, GitHub App private keys, Slack signing secrets, and payment webhook HMAC keys. Storing those values in plain .env files on persistent block volumes—or passing them inside container image build args where docker history exposes them—violates basic secret hygiene.
Using SAU Key Vault KMS (/dashboard/key-vault and Cloud Services), infrastructure teams store versioned secrets encrypted under KMS master keys with strict per-token access auditing. At worker boot, a minimal ExecStartPre bootstrap binary authenticates to Key Vault and writes decrypted credentials exclusively to /run/secrets (tmpfs, backed purely by volatile kernel RAM with 0400 permissions), ensuring zero plaintext secret bytes ever land on persistent storage or disk snapshots:
#!/usr/bin/env bash
# /usr/local/libexec/hydrate-agent-secrets.sh (invoked via systemd ExecStartPre)
set -euo pipefail
install -d -m 0700 -o agent -g agent /run/secrets
TMP_ENV="$(mktemp /run/secrets/agent.env.XXXXXX)"
chmod 0400 "$TMP_ENV"
fetch_secret() {
local name="$1"
curl -fsS --max-time 10 \
-H "Authorization: Bearer ${SAU_VAULT_TOKEN}" \
"https://serversareup.com/api/v1/key-vault/secrets/${name}/latest" \
| jq -er '.value'
}
{
printf 'ANTHROPIC_API_KEY=%s\n' "$(fetch_secret prod-anthropic-key)"
printf 'OPENAI_API_KEY=%s\n' "$(fetch_secret prod-openai-key)"
printf 'SAU_DB_TOKEN=%s\n' "$(fetch_secret prod-cloud-db-token)"
} > "$TMP_ENV"
chown agent:agent "$TMP_ENV"
mv -f "$TMP_ENV" /run/secrets/agent.env
pgvector) and Azure-Backed Artifact ArchivalProduction RAG ingestion pipelines and multi-agent supervisor graphs fail when developers cram embeddings, raw PDFs, and conversation checkpoints onto local SQLite files inside an ephemeral container filesystem. Splitting state by access pattern keeps worker VMs stateless and horizontally replaceable:
pgvector HNSW indexing in one managed service with tunable consistency (STRONG, SESSION, EVENTUAL), optimistic ETag concurrency control (preventing concurrent subagents from clobbering shared task state), and 100K RU/mo (100,000 Request Units/month) free.5 GiB free developer storage and scales from 250 GiB ($9/mo) to 25 TiB ($399/mo) across Hot, Cool, and Archive tiers. Every object receives dual-layer AES-256-GCM + Azure storage encryption, with optional WORM legal holds so compliance teams can prove agent tool-call transcripts were never altered post-execution.-- Multi-tenant agent checkpoint + pgvector semantic memory schema
CREATE EXTENSION IF NOT EXISTS vector;
CREATE TABLE IF NOT EXISTS agent_thread_checkpoints (
thread_id UUID NOT NULL,
step_seq BIGINT NOT NULL,
agent_role TEXT NOT NULL,
state_payload JSONB NOT NULL,
etag TEXT NOT NULL,
artifact_blob TEXT, -- URI in /cloud-storage Archive/Hot container
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
PRIMARY KEY (thread_id, step_seq)
);
CREATE TABLE IF NOT EXISTS agent_semantic_memory (
memory_id UUID PRIMARY KEY,
namespace TEXT NOT NULL,
summary_text TEXT NOT NULL,
metadata JSONB NOT NULL DEFAULT '{}'::jsonb,
embedding vector(1536) NOT NULL,
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_semantic_memory_ns
ON agent_semantic_memory (namespace);
CREATE INDEX IF NOT EXISTS idx_semantic_memory_hnsw
ON agent_semantic_memory
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);
Why optimize AI agent infrastructure around high-IPC Xeon CPUs rather than renting costly idle GPUs? When frontier reasoning runs via hosted APIs (Claude, GPT, Gemini), your own servers spend over 85% of active compute cycles on CPU and memory workloads: spawning isolated Docker/Playwright tool sandboxes, parsing HTML/PDF documents, running AST static analyzers, compressing JSON context payloads, and multiplexing hundreds of concurrent SSE/WebSocket streams.
| Product Tier | Compute & Storage Allocation | Monthly Price | Recommended Control-Plane / Agent Workload |
|---|---|---|---|
| Agent Micro | 1 vCPU, 2 GB RAM, 20 GB persistent storage | $6/mo |
Single Slack/GitHub ops bot, lightweight cron supervisor, or Streamable HTTP MCP proxy |
| Agent Standard | 2 vCPU, 4 GB RAM, 60 GB persistent storage | $10/mo |
Production MCP server + Redis task queue + multi-step LangGraph/CrewAI coordinator |
| Agent Pro | 4 vCPU, 16 GB RAM, 200 GB persistent storage | $24/mo |
Memory-intensive RAG chunking/reranking workers, Dify/n8n stacks, and Playwright pools |
| Agent Enterprise | 8 vCPU, 32 GB RAM, 500 GB persistent storage | $38/mo |
Concurrent sandboxed code-execution runners, multi-tenant agent fleets, and observability |
| Linux Cloud VPS | 2–16 vCPU, 2–48 GB RAM, 50–960 GB persistent storage | $6–$56/mo |
Full root KVM hosts with 69 free 1-click self-hosted AI & DevOps app installers |
| Hybrid Fleet | External cloud or on-prem servers (including external GPU nodes) | $3/machine/mo |
Bring external vLLM/Ollama GPU boxes into the same SAU browser console, VPN mesh, and MCP API |
For process-level sandboxing, seccomp egress filtering, and long-lived SSE worker templates inside each VM, continue with our 24/7 stateful AI agent hosting guide and automated server provisioning guide.
No. Servers Are Up specializes in high-IPC Intel Xeon CPU virtual machines, containers, pgvector cloud databases, KMS vaults, and MCP control planes purpose-built for AI orchestration, RAG ingestion, and tool-calling agents paired with external LLM APIs. If you run dedicated GPU hardware elsewhere or on-premises, enroll it via /dashboard/hybrid ($3/machine/mo) to manage both planes from one console and WireGuard network.
/api/v1 REST and /api/mcp/v1 Streamable HTTP MCP?Both endpoints operate on the exact same underlying infrastructure resources, RBAC scopes, and audit trails. Use /api/v1 REST from deterministic TypeScript/Python/Go services, CI pipelines, and IaC scripts; use /api/mcp/v1 (129 sau_* tools) when connecting MCP-native LLM agents so tool discovery, parameter schemas, and streaming execution responses work out of the box.
Never grant an autonomous agent an account-wide owner token. Issue a scoped Personal Access Token restricted to read-only inspection or confined to a fixed-budget Virtual Datacenter pool (such as a $12/mo Hobby Lab or $24/mo Developer Studio), where hard vCPU, RAM, storage, and instance-slot ceilings prevent billing runaways at the hypervisor quota layer.
/cloud-storage) instead of VM disks?Storing multi-gigabyte PDF corpora and agent execution traces on local VM volumes bloats backup times and couples data durability to a single worker instance. Offloading objects to Managed Cloud Storage hosted via Microsoft Azure (5 GiB free, AES-256-GCM + Azure storage encryption, Hot/Cool/Archive tiers, and WORM holds) lets you replace or autoscale stateless compute workers freely.
Explore With AI & Cite This Page
Open a grounded prompt in your AI assistant or copy a clean Markdown, HTML, or APA reference link.
Validate protocols and subnets directly in your browser or continue reading related architecture notes.
Free WHOIS & RDAP Domain & ASN Lookup Tool
SSH Keygen Generator & Cloud-Init YAML Builder
Cloud Cost & Infrastructure ROI Calculator
AI Agent Infrastructure & Streamable HTTP MCP Hosting (2026): Sandboxed KVM VMs & 129 Scoped Tools
How to architect production AI agent infrastructure and Streamable HTTP Model Context Protocol (MCP) servers in 2026: KVM kernel isolation, dynamic PAT scope filtering across 129 sau_* tools, async 202 reservations, and SSE reverse-proxy tuning.
What Is the Best VPS for Running AI Agents? Hand Your Infrastructure to Claude with the v1 API
What is the best VPS for running AI agents? Compare top AI agent VPS providers, memory and vCPU sizing for Claude Code, OpenClaw, MCP, Dify, and n8n, and manage your server with our scoped v1 REST API and 129-tool MCP server.
How to Package, Host, and Register a Production Model Context Protocol (MCP) Server in 2026
Complete engineering blueprint for shipping a stateless Streamable HTTP MCP server with SEP-1649 /.well-known/mcp/server-card.json discovery, scoped Bearer/OIDC tokens, and listing it across official MCP registries.
Multi-Cloud Management Dashboard Architecture: Unified Control Plane Design for Hybrid Fleets
Systems architecture for a multi-cloud control plane normalizing compute lifecycle, hybrid enrollment (DIRECT, GATEWAY, CONNECTOR), WireGuard meshes, and lease-based state machines across 7+ providers.