Skip to main content
Servers Are Up
Virtual Datacenter
PricingFree Tools
Sign inBrowse catalog
Servers Are Up
Virtual Datacenter
PricingFree Tools
Sign inBrowse catalog
Servers Are Up

Your apps, automation and data on hardware we own. Build a private stack with predictable capacity and access through your dashboard, API or SSH.

SLA with service creditsOwned hardwareUS-based

Make room for your next idea

Explore the capacity, apps and access options that fit your workload. Check current availability and your total before you buy.

Sign up freeView Pricing

Products

  • Linux VPS
  • Windows VPS
  • Cloud & SaaS Services
  • Cloud Storage (Azure)
  • Virtual Datacenter
  • AI & Agent Hosting
  • Containers
  • Instant Apps
  • Software Platforms
  • Network builder
  • Game Servers
  • Pricing

Resources

  • Free Network Tools
  • 2026 Pricing Benchmark
  • Live SVG Badges
  • Latency & Speed Test
  • Guides & Tutorials
  • Documentation
  • API Reference
  • MCP Server
  • CLI & SDKs
  • OpenAPI & llms.txt
  • Use Cases
  • Free Migration
  • Uptime & Reliability
  • Datacenter
  • System Status
  • Network
  • Provider Comparisons Hub
  • Compare Providers

Company

  • About Us
  • Enterprise
  • Security Architecture
  • Trust Center
  • Blog
  • FAQ
  • Compliance
  • Startup Program
  • Open-Source Sponsorship
  • Press & Media Kit
  • Referral Program
  • Help Center
  • Contact Us
© Servers Are Up
TermsPrivacySLARefund PolicyDPAAcceptable Use
Service information
Back to Engineering BlogAI Agents & MCP
Servers Are Up Engineering·Published 2026-11-13·10 min read·Technical Review Verified

AI Infrastructure Management: Deterministic Control Planes, MCP Tooling, and Stateful Agent Fleets

ai infrastructure management ai server management ai for server management

Engineering Summary & Direct Answer

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.

Instant 60s deploy · Browser SSH & WebRDP included
Explore AI & MCP Hub Read MCP DocsVirtual Datacenter Pools ($12–$380/mo)
On this page (7 sections)
  1. Separating Probabilistic Reasoning from Deterministic Control Planes
  2. Unified Programmatic Control: REST (/api/v1) and Streamable HTTP MCP (/api/mcp/v1)
  3. Ephemeral SSH Key Leasing via sau_ssh_authorize
  4. Secret Hydration with SAU Key Vault KMS
  5. Vector State (pgvector) and Azure-Backed Artifact Archival
  6. Sizing CPU Orchestration Planes on Servers Are Up
  7. Frequently Asked Questions
  8. Does Servers Are Up offer GPU VMs for model training or local LLM inference?
  9. What is the difference between /api/v1 REST and /api/mcp/v1 Streamable HTTP MCP?
  10. How do I stop a runaway AI agent from provisioning unbounded servers or deleting data?
  11. Why store RAG artifacts in Managed Cloud Storage (/cloud-storage) instead of VM disks?

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.

Separating Probabilistic Reasoning from Deterministic Control Planes

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:

  1. Typed Tool Contracts Over Raw Shell Interpolation: Agents invoke strongly typed JSON-RPC or REST operations (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.
  2. Capability Tiering and Blast-Radius Quotas: Read-only observability tools execute freely; reversible lifecycle actions (restarting a wedged worker container, scaling within a pre-funded pool) run behind token-bucket rate limits; destructive mutations (deleting persistent storage, modifying public firewall ingress, altering billing) require out-of-band human approval.
  3. Zero Static Host Credentials: Neither the orchestrator nor the agent stores permanent id_ed25519 private keys on disk. Host access uses short-lived cryptographic leases (60–3600 seconds) that self-expire at the platform layer.
  4. Externalized Durable State: Agent worker nodes remain stateless and disposable; embeddings, graph checkpoints, secrets, and raw artifacts live in managed, encrypted backing services.

Unified Programmatic Control: REST (/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:

  • REST v1 API (/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.
  • Streamable HTTP Model Context Protocol Server (/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}"
      }
    }
  }
}

Ephemeral SSH Key Leasing via sau_ssh_authorize

Static 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.

Secret Hydration with SAU Key Vault KMS

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

Vector State (pgvector) and Azure-Backed Artifact Archival

Production 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:

  1. Semantic Retrieval & Graph Checkpoints (SAU Multi-Model Cloud Database): Combines SQL tables, JSON documents, key-value lookups, and native 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.
  2. Immutable Corpora & Audit Logs (Managed Cloud Storage hosted via Microsoft Azure): Starts with 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);

Sizing CPU Orchestration Planes on Servers Are Up

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.

Frequently Asked Questions

Does Servers Are Up offer GPU VMs for model training or local LLM inference?

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.

What is the difference between /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.

How do I stop a runaway AI agent from provisioning unbounded servers or deleting data?

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.

Why store RAG artifacts in Managed Cloud Storage (/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.

AI Agent Hosting & 129-Tool Streamable HTTP MCP

Run 24/7 Stateful Agents & Operate Infrastructure via MCP

Dedicated Agent runtimes from $6/mo, Linux KVM nodes from $6/mo ($18/mo for 4 vCPU / 8 GB ECC RAM), and 129 native MCP tools at /api/mcp/v1.

Explore AI & MCP Hub Read MCP Docs

Explore With AI & Cite This Page

Open a grounded prompt in your AI assistant or copy a clean Markdown, HTML, or APA reference link.

Ask ChatGPT Ask Perplexity Ask Claude
Share:HN·Reddit·X·LinkedIn
Newer Article

Building Zero-Trust Stateful Apps Without Hyperscaler Lock-In: Inside SAU Multi-Model Cloud DB, ES256 OIDC, Key Vault & Cloud SIEM

Older Article

Cloud Cluster Architecture: Raft Quorum Math, etcd Latency, East-West MTU, and K3s Topology

Related Diagnostic Tools & Engineering Guides

Validate protocols and subnets directly in your browser or continue reading related architecture notes.

Free Browser Tool

Free WHOIS & RDAP Domain & ASN Lookup Tool

Launch utility
Free Browser Tool

SSH Keygen Generator & Cloud-Init YAML Builder

Launch utility
Free Browser Tool

Cloud Cost & Infrastructure ROI Calculator

Launch utility

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.

On this page

  1. Separating Probabilistic Reasoning from Deterministic Control Planes
  2. Unified Programmatic Control: REST (/api/v1) and Streamable HTTP MCP (/api/mcp/v1)
  3. Ephemeral SSH Key Leasing via sau_ssh_authorize
  4. Secret Hydration with SAU Key Vault KMS
  5. Vector State (pgvector) and Azure-Backed Artifact Archival
  6. Sizing CPU Orchestration Planes on Servers Are Up
  7. Frequently Asked Questions
  8. Does Servers Are Up offer GPU VMs for model training or local LLM inference?
  9. What is the difference between /api/v1 REST and /api/mcp/v1 Streamable HTTP MCP?
  10. How do I stop a runaway AI agent from provisioning unbounded servers or deleting data?
  11. Why store RAG artifacts in Managed Cloud Storage (/cloud-storage) instead of VM disks?
Self-Serve Infrastructure

Run 24/7 Stateful Agents & Operate Infrastructure via MCP

Dedicated Agent runtimes from $6/mo, Linux KVM nodes from $6/mo ($18/mo for 4 vCPU / 8 GB ECC RAM), and 129 native MCP tools at /api/mcp/v1.

Explore AI & MCP Hub Read MCP Docs