What is Sabrix?

Sabrix is the execution control plane for enterprise AI agents. It governs which actions agents can take in production, binds approvals to exact operations, and manages failures and uncertain downstream outcomes.

Ship agents that can take action in production—with enforced limits, exact approvals, and clear handling of failed or uncertain operations.

Standard prompt filters and token guardrails inspect text after generation. Once agents invoke tools, connect to APIs, and execute SQL statements, text filters fail. On configured execution paths, Sabrix acts as an in-VPC gatekeeper to validate execution policy before a requested mutation dispatches to downstream systems.

Why Execution Control Matters

How an execution control plane fundamentally differs from passive post-hoc chatbots and passive observability proxies:

Execution Control Integration & Prerequisites

Deploy Sabrix as an in-VPC Layer 7 execution control plane adjacent to agent workloads. Evaluates policy rules, blocks unauthorized tool side-effects, and issues durable execution claims before actions dispatch.

# Run in-VPC standalone execution control plane with persistent execution storage
docker run -d --name sabrix-control-plane \
  -p 127.0.0.1:8080:8080 \
  -p 127.0.0.1:8090:8090 \
  -p 127.0.0.1:9090:9090 \
  -v $(pwd)/sabrix-records:/var/lib/sabrix/records \
  -e ADMIN_API_KEY="${ADMIN_API_KEY:?Set ADMIN_API_KEY}" \
  -e UPSTREAM_ADDR="https://api.openai.com" \
  -e SABRIX_FAILURE_MODE=closed \
  ghcr.io/sabrix-ai-inc/sabrix-proxy:latest

# Configure supported tool clients to route outbound action traffic through Action Forward Proxy (:8090)
export HTTP_PROXY="http://127.0.0.1:8090"
export HTTPS_PROXY="http://127.0.0.1:8090"

Listener addresses are configurable via environment variables (LISTEN_ADDR, FORWARD_LISTEN_ADDR, ADMIN_LISTEN_ADDR). VPC placement does not replace ingress authentication or egress firewall controls.

Architecture Overview & State Demarcation

Internal layer state boundaries and crash-resilient failure semantics:

Core Security Model & Tool Governance

Execution Authority & Durable Claims

Crash recovery reconciles outstanding execution claims upon gateway restart according to the configured execution path and authority provider, rejecting uncommitted dispatches when configured in fail-closed mode.

Multi-Language Code Matrix

Layer 7 controls over standard HTTP sockets. SDK types and tools remain 100% standard:

These headers carry routing and agent context. Configure authenticated ingress before trusting caller-supplied values.

LangGraph Multi-Agent Integration

Configure per-client routing headers for supervisor and delegated worker nodes to carry agent identity and lineage:

import os
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI

supervisor_llm = ChatOpenAI(
    model="gpt-4o",
    base_url=os.environ.get("OPENAI_BASE_URL", "http://127.0.0.1:8080/v1"),
    default_headers={"x-sabrix-tenant": "acme", "x-sabrix-agent-id": "supervisor", "x-sabrix-agent-role": "admin"}
)
worker_llm = ChatOpenAI(
    model="gpt-4o",
    base_url=os.environ.get("OPENAI_BASE_URL", "http://127.0.0.1:8080/v1"),
    default_headers={"x-sabrix-tenant": "acme", "x-sabrix-agent-id": "worker-1", "x-sabrix-parent-agent-id": "supervisor"}
)

# Requires: python3 -m pip install autogen-agentchat "autogen-ext[openai]"
import asyncio, os
from uuid import uuid4
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient

async def main():
    client = OpenAIChatCompletionClient(
        model="gpt-4o",
        api_key=os.environ.get("OPENAI_API_KEY", "${OPENAI_API_KEY:?Set OPENAI_API_KEY}"),
        base_url=os.environ.get("OPENAI_BASE_URL", "http://127.0.0.1:8080/v1"),
        default_headers={
            "x-sabrix-tenant": "acme",
            "x-sabrix-agent-id": "autogen-assistant",
            "x-sabrix-agent-role": "viewer",
            "x-sabrix-session-id": str(uuid4()),
        },
    )
    try:
        assistant = AssistantAgent("analyst", model_client=client)
        result = await assistant.run(task="Reply with a short greeting.")
        print(result.messages[-1].content)
    finally:
        await client.close()

if __name__ == "__main__":
    asyncio.run(main())

Docker Standalone Deployment

Deploy Sabrix as an In-VPC container adjacent to your application workloads with persistent state storage:

docker run -d --name sabrix-control-plane \
  -p 127.0.0.1:8080:8080 \
  -p 127.0.0.1:8090:8090 \
  -p 127.0.0.1:9090:9090 \
  -v /var/run/sabrix/records:/var/lib/sabrix/records \
  -e ADMIN_API_KEY="${ADMIN_API_KEY:?Set ADMIN_API_KEY}" \
  -e UPSTREAM_ADDR="${UPSTREAM_ADDR:-https://api.openai.com}" \
  -e SABRIX_FAILURE_MODE=closed \
  ghcr.io/sabrix-ai-inc/sabrix-proxy:latest

Kubernetes Sidecar & DaemonSet Topologies

Sidecar container adjacent to agent pods with bounded resource requests (32Mi request / 64Mi limit):

Provision secret: kubectl create secret generic sabrix-secrets --from-literal=admin-api-key="${ADMIN_API_KEY:?Set generated ADMIN_API_KEY}"

apiVersion: apps/v1
kind: Deployment
metadata: { name: agent-worker-deployment }
spec:
  replicas: 5
  selector:
    matchLabels: { app: agent-worker }
  template:
    metadata:
      labels: { app: agent-worker }
    spec:
      containers:
        - name: agent-worker
          image: internal-registry.io/agent:v2.1
          env: [{ name: OPENAI_BASE_URL, value: "http://127.0.0.1:8080/v1" }]
        - name: sabrix-sidecar
          image: ghcr.io/sabrix-ai-inc/sabrix-proxy:latest
          env:
            - name: ADMIN_API_KEY
              valueFrom: { secretKeyRef: { name: sabrix-secrets, key: admin-api-key } }
            - name: UPSTREAM_ADDR
              value: "https://api.openai.com"
            - name: SABRIX_FAILURE_MODE
              value: "closed"
          resources: { requests: { memory: "32Mi", cpu: "50m" }, limits: { memory: "64Mi", cpu: "500m" } }

Observability: OpenTelemetry & Prometheus

W3C OpenTelemetry spans and Prometheus metrics on data plane (:8080) and authenticated admin port (:9090). Counter definitions:

• plenum_requests_total: Requests counted by this proxy instance’s gateway processing path.
• sabrix_wal_dropped_total: Recorded WAL audit-event drops, including queue saturation, queue closure, and rotation-capacity failures. Investigate any increase.
• sabrix_durability_rejections_total: Requests rejected because durability preconditions failed.

set -o pipefail
curl -fsS -H "Authorization: Bearer ${ADMIN_API_KEY:?Set ADMIN_API_KEY}" \
  http://127.0.0.1:9090/metrics | grep -E '^(sabrix_wal_dropped_total|sabrix_durability_rejections_total|plenum_requests_total)(\{|[[:space:]])'

Verify your integration

Validate the configured gateway with a representative workflow before connecting production agents:

1. Send a permitted request and confirm the expected upstream response.
2. Send a request prohibited by your configured policy and confirm rejection before the downstream action executes.
3. Inspect the resulting audit records and operational metrics.

For distributed deployments, also verify quorum-loss behavior and the downstream system's retry and fencing contract.

Optional Utility: Client-Side Context Compaction

Sabrix primarily operates as an In-VPC Layer 7 execution control plane for governing tool actions, external API mutations, and durable state. As a separate and optional optimization utility, Sabrix provides standalone client-side compaction libraries (sabrix_compactor.py and @sabrix/compactor) for agent runtimes that experience heavy token consumption from repetitive tool outputs.

from sabrix_compactor import wrap_client
from openai import OpenAI

# Wraps standard client in-process
client = wrap_client(OpenAI())
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Analyze logs"}]
)

import { wrapClient } from '@sabrix/compactor';
import OpenAI from 'openai';

// Wraps standard OpenAI client in-process
const openai = wrapClient(new OpenAI());
const res = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Audit spend' }]
});