Enterprise AI gateway architecture

One enterprise AI gateway. Every provider. Enforceable policy.

Entrovik is a server-side enterprise AI gateway and policy runtime: OpenAI-compatible ingress, provider normalization, deterministic pipelines, sandboxed policy code, and tenant-scoped control APIs.

Schedule an architecture review ↗Run the live policies →

Execution architecture

Policy runs on both sides of every model call.

Provider-specific payloads are normalized before policy evaluation, keeping policy packages portable across vendors and API shapes.

CLIENTApp / AgentOpenAI SDK

INGRESSNormalizeChat · Responses · Embeddings

REQUEST PIPELINEWASM policiesInspect · Mutate · Deny

PROVIDERModel adapterCloud · Private · Local

RESPONSE PIPELINEWASM policiesInspect · Redact · Audit

Developer surface

Compatible at ingress. Normalized inside.

Point compatible clients at Entrovik, keep policy logic out of applications, and add providers without rewriting your governance layer.

POST /v1/chat/completions

Chat completions

OpenAI-compatible message, multimodal text, tool-call normalization, and buffered or guarded-live SSE delivery.

POST /v1/responses

Responses API

Normalized Responses input and output with the same ordered request and response enforcement.

POST /v1/embeddings

Embeddings

Govern embedding inputs through provider capability adapters with safely handled unsupported operations.

POST /v1/policy/evaluate

Provider-free enforcement

Run active request or response policy for managed browser prompts, extracted text attachments, and optional displayed responses without contacting a provider.

provider.Provider

Native adapters

OpenAI-compatible, Anthropic, and Gemini adapters translate content, errors, tools, and usage at one boundary.

apiVersion: v1

Stable policy ABI

JSON-serialized policy inputs and results avoid exposing Go memory or internal structs to plugins.

/api/v1/...

Administrative API

Versioned, tenant-scoped APIs power the UI and CLI for automation without shell or CLI bridges.

streaming.mode

Explicit SSE security modes

Use secure buffered delivery by default, guarded live streaming where policy permits it, or disable streaming entirely.

WASM-first policies

External logic without native plugin risk.

Policies are independently packaged, versioned, validated, integrity-checked, and executed through wazero without CGO.

Discuss policy development →

CAPABILITIES / DEFAULT

No filesystem, network, environment, or process access

The v1 ABI is capability-denied by default. Future permissions can be introduced explicitly without making ambient host access the norm.

RESOURCE CONTROL

Bounded execution under hostile conditions

Initialization and execution timeouts, memory limits, input and output ceilings, concurrency controls, and trap recovery isolate defective policies.

FAILURE SEMANTICS

Explicit fail-open or fail-closed behavior

Each policy defines what happens on timeout, trap, ABI mismatch, malformed output, or evaluation failure.

SUPPLY CHAIN

Checksums, publishers, trust, and package lifecycle

Policy packages carry versioned manifests, SHA-256 integrity, publisher identity, configuration schema, documentation, and trust metadata.

DEVELOPER EXPERIENCE

Build, test, package, and sign workflows

The CLI and Go/Rust SDK surfaces support rapid policy authoring with ABI conformance and deterministic package validation.

Open the developer guide →

Declarative governance

Order, configure, and promote policy as controlled configuration.

Pipeline revisions are validated and applied through tenant-scoped control APIs with immutable history and rollback.

Ordered request, response, and audit stages
Policy bundles with pinned versions and defaults
Plan changes before applying a new revision

governance.yaml VALID

apiVersion: entrovik.com/v1
kind: GovernanceConfig
policies:
  - name: detect-secrets
    enabled: true
    config:
      action: deny
  - name: pii
    enabled: true
    config:
      action: redact
pipeline:
  request: [detect-secrets, pii, model-policy]
  response: [detect-secrets, pii]
  audit: [audit]

Production topology

Operational controls for high-value infrastructure.

IDENTITY

OIDC, API keys, and RBAC

Browser Authorization Code with PKCE, signed bearer validation, service clients, roles, teams, and server-enforced tenant isolation.

PERSISTENCE

SQLite to PostgreSQL HA

Durable SQLite for a single process; transactional PostgreSQL with serialized migrations for horizontally scaled deployments.

SECRETS

External secret references

Environment, Kubernetes, Vault KV v2, AWS, Google, and Azure secret-provider integrations keep values out of APIs and logs.

RESILIENCE

Provider guards

Concurrency caps, circuit breakers, request limits, redirect rejection, sanitized errors, and intentionally conservative retry behavior.

OBSERVABILITY

Metrics and request correlation

Prometheus-compatible metrics, structured JSON logs, request IDs, health/readiness endpoints, policy latency, usage, and cost.

DEPLOYMENT

Container and Kubernetes

Non-root distroless image, Helm chart, security contexts, network policy, autoscaling, disruption budgets, affinity, and tolerations.

Architecture review

Put policy in the path—not in every codebase.

Walk through your provider topology, client compatibility, identity model, policy requirements, and deployment constraints with us.

Request technical review ↗Review security →