Private AI · on-premises & air-gapped

AI that never leaves your network.

Local LLMs and agents running on your own hardware, behind your firewall, for work where data egress is not an option. Proxmox, Docker, PyTorch, Ollama, vLLM — open-source throughout.

GPU server glowing amber in a dark rack — the private inference box

01 · stack

The layers, end to end.

A coherent stack — hypervisor to agents — chosen so every layer is replaceable, every model is auditable, and nothing depends on a third-party API.

Hypervisor · Proxmox VE 9 — technical illustration
Hypervisor · Proxmox VE 9
KVM virtual machines and LXC containers on a single platform, with GPU passthrough into the inference VM — NVIDIA (full passthrough or vGPU) and AMD (PCIe passthrough) alike. HA clustering and live migration across nodes, nightly Proxmox Backup Server snapshots. Open-source under AGPLv3 — no per-socket licensing.
Container layer · Docker — technical illustration
Container layer · Docker
Reproducible, versioned images for every service — Ollama, vLLM, Postgres, the agent gateway. NVIDIA Container Toolkit exposes the GPU to containers; rootless mode, read-only filesystems, and no-new-privileges are the baseline. Everything is rebuildable from the compose files in git.
Inference · Ollama & vLLM — technical illustration
Inference · Ollama & vLLM
Open-weight models served over an OpenAI-compatible local API. Ollama for simplicity and quick iteration; vLLM (a PyTorch Foundation project) when throughput, batching, and PagedAttention matter. Fully offline once the model weights are pulled — inference never calls out.
Runtime underneath · PyTorch — technical illustration
Runtime underneath · PyTorch
The framework beneath fine-tuning and embedding pipelines — PyTorch stable 2.7, on CUDA 12.8 for NVIDIA and ROCm 6.x for AMD. Used when a general open-weight model is not enough and a domain-tuned embedder or LoRA adapter needs to live in the same box.
Agents · LangGraph & custom loops — technical illustration
Agents · LangGraph & custom loops
Reasoning loops over the local API — LangGraph or hand-rolled — with least-privilege tools and a human-in-the-loop gate on every write action. The agent sees only what its scope allows; every tool call is logged before it runs.

stack · gpu paths

Two GPU paths, one playbook.

Hardware choice is a budget and supply-chain decision, not a lock-in. The same stack runs on both vendors — the real differences live in three places: passthrough setup, runtime flags, and serving maturity.

Graphics card with amber light trails — NVIDIA CUDA path
NVIDIA · CUDA
The path of least resistance. CUDA 12.8 across the whole stack — PyTorch, vLLM, Ollama — with full passthrough or vGPU on Proxmox (live migration on datacenter cards).
  • RTX / datacenter cards, passthrough or vGPU
  • CUDA 12.8 wheels — no patchwork, no flags
  • Best for: smoothest tooling, mixed training + inference
Radeon graphics card with red and amber light — AMD ROCm path
AMD · ROCm
More VRAM per dollar. ROCm 6.x on Radeon (7900 XTX, 24 GB class) or Instinct — full PCIe passthrough into the inference VM, ROCm builds of Ollama, vLLM, and PyTorch. A little more care: verify the supported-GPU list, and set the gfx override on unofficial cards.
  • Radeon 7900 XTX / Instinct MI series via PCIe passthrough
  • ROCm builds of Ollama, vLLM, and PyTorch 2.7
  • Best for: maximum VRAM per dollar, inference-first boxes

02 · security posture

Six things that are not optional.

A private AI platform is only as good as the boring controls behind it. These are the defaults on every build.

  1. 01 · Zero egress

    Inference and data stay inside the LAN. Open-weight models are pulled once during provisioning, then the upstream connection is closed. The inference VLAN has no default route to the public internet.

  2. 02 · Segmentation

    AI workloads live in their own VLAN and firewall zone, separated from user endpoints. MikroTik rules between zones; admin plane on a dedicated management network with its own ACLs.

  3. 03 · Provenance & integrity

    Every model version is pinned (tag + SHA), checksum-verified before load, and limited to the safetensors format. No pickle, no remote code execution paths, no surprises at deploy time.

  4. 04 · Least-privilege agents

    Agents start read-only. Tools that write — to disk, to a database, to an external system — require explicit human approval per call. The default is 'ask', not 'act'.

  5. 05 · Secrets hygiene

    No API keys, tokens, or credentials in prompts, logs, or commit history. A local secret store (HashiCorp Vault or equivalent) with short-lived credentials and documented rotation.

  6. 06 · Auditability

    Append-only logs of every request, tool call, and action — enough to answer 'what did the agent do, and why' months later. Retention is configurable; integrity is signed.

03 · reference architecture

How the pieces connect.

The same shape every time: users reach the agent gateway through a reverse proxy, the gateway talks to Ollama or vLLM on the GPU VM, and nothing crosses the VLAN boundary.

  ┌─────────────────────────────────────────────────────────────────┐
  │  users (browser / api clients)                                  │
  └─────────────────────────────────────────────────────────────────┘
                              │ tls
                              ▼
  ┌─────────────────────────────────────────────────────────────────┐
  │  reverse proxy · nginx / caddy                                  │
  └─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
  ┌─────────────────────────────────────────────────────────────────┐
  │  agent gateway · langgraph / custom loop                        │
  │   · read-only tools by default                                  │
  │   · human-in-the-loop gate on every write action                │
  │   · append-only audit log                                       │
  └─────────────────────────────────────────────────────────────────┘
            │                            │                │
            ▼                            ▼                ▼
  ┌──────────────────┐    ┌─────────────────────────┐   ┌──────────────┐
  │ postgres + vector │    │ ollama / vllm           │   │ object store │
  │ (rag, audit)      │    │ gpu vm · open weights   │   │ (docs, logs) │
  └──────────────────┘    └─────────────────────────┘   └──────────────┘
            │                            │                │
            └──────────── vlan · ai-internal ──────────────┘
                              │ no egress
                              ▼
                          (firewall)
vlan · ai-internal · no egressreference-arch · ascii

04 · engagements

Four shapes the work usually takes.

Each engagement is sized and quoted after diagnosis. Pick the one that matches the problem, or combine them.

Private LLM platform
Stand up a working private-LLM platform on your hardware: cluster sizing, Proxmox deployment, GPU VM configuration, Ollama or vLLM serving, monitoring, and backups.

What’s included

  • Sizing & hardware plan (CPU, RAM, GPU, storage, network)
  • Proxmox VE 9 cluster with HA and live migration
  • GPU passthrough / vGPU into the inference VM — NVIDIA CUDA or AMD ROCm
  • Ollama or vLLM with pinned model versions and safetensors-only
  • Monitoring (node, GPU, queue depth) and Proxmox Backup Server snapshots
Agents for sensitive operations
Build and deploy agents that touch real internal data — RAG over your documents, ops copilots, workflow automation — with approval gates on every write.

What’s included

  • RAG over internal documents (Postgres + pgvector, or a vector DB of your choice)
  • Tool/function calling with a least-privilege tool registry
  • Human-in-the-loop approval on every write action
  • Append-only audit log for every agent step
Hardening & operations
Keep a private-AI platform quietly running — patch cadence, model-update pipeline, DR drills, capacity planning, and incident runbooks.

What’s included

  • Patch cadence for hypervisor, containers, and base images
  • Model-update pipeline with canary rollout and rollback
  • Disaster-recovery drills and runbook validation
  • Capacity planning against sustained token throughput
Cloud-to-local migration
Move a workload that is leaking prompts or sensitive data to a third-party API — back onto your own metal. Inventory what leaves today, run parity tests, cut over in stages.

What’s included

  • Inventory of current external API calls and what they carry
  • Parity testing against the chosen local model(s)
  • Staged cutover with shadow traffic and rollback points
  • Documentation and runbooks for the new platform

05 · when this is the right call

If any of these sound like you, we should talk.

Private AI is the right answer when the public option is the wrong answer. A few honest signals.

  • Regulated data — health, legal, finance — that cannot leave controlled environments.

  • Trade secrets or IP inside the prompts: code, models, contracts, customer data, internal strategy.

  • Offline or low-connectivity sites — research vessels, plants, secure facilities — where the link is intermittent or absent.

  • Predictable cost at sustained load — flat hardware spend instead of per-token billing that scales with adoption.

/contact

Have data that can’t leave the building?

Tell me what you’re running, what it touches, and what it cannot do. I read every note and reply within two business days.

Start a conversation