§ Architecture

How Arkheia deploys

One product. Multiple deployment modes. A transparent sidecar proxy between your application and your models — no code changes, no SDK, no model modifications.

Language: Python 3.11+Protocol: OpenAI-compatible RESTStorage: File-based (no DB)Network: Air-gap compatibleAuth: API Key (SHA-256) + License (HMAC)

§ 01 — Deployment options

Choose where you need control. Each deployment mode has a defined trust boundary and information flow. Expand any card to see the architecture diagram with animated flows.

Deployment modes
One product. Choose where you need control.
CapabilityPublic ProxyEnterprise ProxyMCP Control PlaneIsolated Deployment
Hosted by Arkheia
Private deployment
Multi-model support
Inline filtering (safe / review / hold)
Custom policy gates
Central control plane orchestration
Isolated boundary for high-sensitivity workflows
Audit logs (exportable)
Enterprise support + SLA

§ 02 — Enterprise vLLM integration

Zero-modification deployment

Arkheia deploys as a transparent sidecar proxy between your application and your existing vLLM inference server. No code changes, no SDK, no model modifications. Your application talks to Arkheia exactly as it would talk to vLLM directly — the OpenAI-compatible API contract is preserved.

Before

Your App

vLLM

After

Your App

Arkheia

vLLM

// Zero-modification deployment — change one line

# Before
OPENAI_BASE_URL=http://vllm:8000

# After
OPENAI_BASE_URL=http://arkheia:8080

What Arkheia adds to every response:

{ "arkheia": { "risk": "LOW", "confidence": 0.92, "strategy": "ensemble" } }

§ 03 — System topology

Five microservices

Five FastAPI microservices communicate over internal HTTP. All services are independently deployable and fail gracefully — if any support service goes down, detection continues.

ServiceRoleIf Unavailable
Detection ProxyprimaryRequest interception, analysis, enrichmentMust be running
Surface ManagerProfile hot-reload (filesystem watcher)Profiles frozen at last load
License ValidatorTime-based license + HMAC verificationConfigurable grace period applied
Config ServiceRuntime threshold overrides, feature flagsUses baked-in defaults
Audit LoggerCompliance logging to JSONL + in-memory bufferDetection continues, logs preserved

§ 04 — Telemetry flow

Signal without content

The on-prem engine derives a runtime signal from two observable surfaces. Telemetry is collected locally, processed within the detection engine, and emitted as a risk signal. No prompts, responses, or application content are inspected or retained.

Model Telemetry

Token logprobs from vLLM

Hardware Telemetry

CPU / memory / bandwidth

Feature Extraction

Local processing only

Risk Signal

LOW / MEDIUM / HIGH

§ 05 — Profile system & adaptive routing

Zero code changes for new models

Model profiles are YAML files loaded at startup and hot-reloaded at runtime. The adaptive router selects the optimal profile variant based on actual response characteristics.

Adding a new model requires zero code changes. Drop a new YAML profile into profiles/ and the Surface Manager hot-reloads it. All detection parameters, thresholds, and feature weights are data-driven.

YAML Profiles

Per-model configuration files. Each defines features, thresholds, weights, and short-response handling.

Adaptive Router

Selects profile variant based on finish_reason and token count. Handles short responses, truncations, and normal completions differently.

Surface Manager

Filesystem watcher on the profiles/ directory. Hot-reloads profiles without service restart. Fails gracefully — profiles freeze at last state.

§ 06 — Operational tenets

Architectural, not configurable

Content Independence

The engine does not inspect, store, or process application prompts or response content. Runtime signals are derived solely from model telemetry and hardware telemetry.

Network Independence

The on-prem engine operates without external service dependencies. It does not initiate outbound connections, perform remote updates, or require internet access. All processing occurs locally within the deployment boundary.

§ 07 — Security architecture

Defence-in-depth

API key authentication, license verification, and hashed credential storage. Designed for air-gapped enterprise deployments.

LayerMechanismDetails
TransportTLS 1.2+Optional, configurable via ARKHEIA_TLS_ENABLED
API AuthBearer tokenark_-prefixed keys, SHA-256 hashed at rest
LicenseHMAC-SHA256Signed license JSON, 7-day grace on expiry
Key StorageHashed onlyOriginal keys never stored, constant-time validation
NetworkAir-gap readyZero external API calls, all services internal

Privacy & Data Handling

The engine is designed to minimise exposure of sensitive content. It does not require prompt or response inspection for its primary signal, and should be configured to avoid storing prompts and responses. Operational telemetry is limited to request metadata, token-likelihood features, and optional host telemetry. Where audit logs are required, redaction and retention policies should be applied to meet local governance.

§ 08 — Technology stack

Full stack reference

Core Runtime

LanguagePython 3.11+
Web FrameworkFastAPI + Uvicorn (ASGI)
HTTP Clienthttpx (async)
ValidationPydantic v2
Loggingstructlog (JSON)
ConfigYAML profiles + JSON runtime

Analysis & Detection

AnalysisFeature extraction + calibrated separation checks
Hardwarepsutil (CPU, memory, bandwidth)
ProfilesPyYAML → Pydantic schema
MethodToken-likelihood feature analysis (no content storage)
CalibrationRepresentative characterization runs (profile-driven)

Security

API AuthSHA-256 hashed API keys
LicenseHMAC-SHA256 signature
ScanningBandit (SAST)
SecretsEnvironment variables only

Deployment

ContainerDocker / Docker Compose
OrchestrationKubernetes-ready
StorageFile-based (no database server)
ProtocolsREST OpenAI-compatible
NetworkAir-gap compatible

Ready to deploy?

Talk to the team about on-premise integration for your inference stack, or explore the live governance environment.