Start 14-day trial

Illustration: red threat packets move toward a user and a database; both are blocked by the Kimss gateway.

Your agents. We provide the control plane.

One-line base_url change. Inventory the same afternoon. Kill switch in the same meeting — you keep the Azure, OpenAI, or Anthropic bill you already pay.

Start 14-day Production trial Documentation

Bottom line: Kimss AI is the independent Secure Enterprise Agent Control Plane: a model-agnostic gateway in front of your vaulted providers. Route traffic that already hits api.kimss.ai: registry, identity, Guardrails, named kill switch, governed-request FinOps. It does not host models, does not scan laptops, and is not Kimi (Moonshot AI).

Control plane capabilities

Six surfaces that matter when agents call tools mid-loop — not a laptop rollout.

  • Named Kill Switch

    Disable an agent once; attributed traffic refuses at the gateway with agent_disabled.

    See the drill

  • Authority Boundary

    Validates tool-argument provenance mid-loop — beyond caller auth that basic gateways stop at.

    How it works

  • Threat Intercepts

    Records when policy, content, or egress rules block traffic — inspect the payload one click away.

    View intercepts

  • Guardrails

    Tool-level authorization and policy checks at the gateway before execution.

    Guardrails docs

  • Identity Audit

    Disable and re-enable actions land in Identity audit with agent entity rows.

    Open audit log

  • Provider Vault

    Connect endpoints you already pay for. Keys stay vaulted; inference spend stays on your provider bill.

    Route traffic

Named kill switch

Disable once. Attributed traffic stops at the gateway.

  1. Route one agent through the control plane.
  2. Disable — Agents UI or POST /agent_set_status/ with {"id":"…","status":"disabled","name":"…"} (name optional).
  3. Attributed requests are refused at the gateway (403, agent_disabled) while disabled. Requests already in progress are not interrupted.
  4. Disable and Re-enable appear in Identity audit at /app/audit/log (action disable|enable, entity_type agent, integer row id). Refused gateway calls are not audit rows.

A kill-switch drill you can finish in one meeting on routed traffic: weaker as a slide, stronger as a demo. Included on the 14-day Production trial and paid plans. We do not claim we were first.

kill_switch · drill · illustrative
01 · disable
POST /agent_set_status/
body
{"id":"ext-dw","status":"disabled","name":"My Agent"}
02 · refuse
HTTP 403 Forbidden
body
{"error":{"message":"this agent is disabled (kill switch)","type":"kimss_error","code":"agent_disabled"}}
Agents page showing support-router Disabled with a Re-enable action
Disable an agent from the Agents page. Its requests are refused at the gateway until you re-enable it. Illustrative data

Control and interception

The gateway intercept

Watch the loop: safe traffic passes; an admin arms Disable / kill switch; the next rogue request is refused with agent_disabled.

  1. Safe traffic passes the control plane.
  2. Admin arms Disable / kill switch on the agent.
  3. A rogue request hits the gateway and is refused with 403 agent_disabled.

Illustrative loop — same refuse contract as the drill above; not a live tenant run.

Why not the alternatives

ConcernBasic gatewayKimss
Caller authYesYes
Tool-argument provenanceNoAuthority Boundary mid-loop
Agent kill switchEdge only / noneRe-checked before each completion hop; Disable on Agents → 403 agent_disabled (in-flight not interrupted)
Guardrail blocksVariesThreat Intercepts for policy / content / egress blocks — agent Disable refusals are not listed there
Pricing meterOften per-token / custom quotePublished governed requests

Endpoint scanners sell “every agent on every laptop.” That is a cross-department install. Kimss inventories only routed traffic: weaker as a slide, stronger as a demo you can finish in one meeting.

OpenRouter is a public model exchange. Portkey is inside Palo Alto. Kimss does not mark up inference. Spend stays on the Azure / OpenAI / Anthropic commits you already own.

Authority Boundary and Guardrails

Authority Boundary validates the origin of tool arguments mid-loop and blocks disallowed actions before execution, beyond caller authentication that basic gateways stop at. Tool-level authorization runs at the gateway. Threat Intercepts record when traffic is blocked.

OWASP ASI03 deep dive

Threat Intercepts table with blocked injection and delegation reasons and an Inspect payload
Blocked injection and delegation attempts, with the payload one click away. Illustrative data

Brain and Body

Stateless LLM providers stay yours. Memory, tools, and security run through Kimss: identity, guardrails, and audit in the gap.

The Brain Your keys. Your tenancy. Azure OpenAI OpenAI · Anthropic OpenAI-compatible endpoints Kimss Identity · Kill · Audit Guardrails · Registry The Body Execution you can govern. Registered agents Memory · tools · MCP Runtime authorization

Security and compliance

Key Vault envelope encryption

In production, Kimss refuses to store a provider key unless Azure Key Vault wrapping is configured. The API is client-write-only.

No default prompt retention

The proxy records correlation IDs, identity claims, and token counts, not full request/response bodies in the telemetry pipeline.

  • Microsoft Entra SSO
  • SCIM 2.0 (Scale and Enterprise)
  • APIM GatewayLogs
  • Retention controls

Read the Trust Center

Developers

Point your existing client at the control plane. One base_url change; then POST /v1/agents/run.

python · illustrative 
from openai import OpenAI

client = OpenAI(
    base_url="https://api.kimss.ai/v1",
    api_key=os.environ["KIMSS_API_KEY"],
)

# Or: POST /v1/agents/run with your registered agent_id
resp = client.chat.completions.create(
    model="vaulted-endpoint-alias",
    messages=[{"role": "user", "content": "ping"}],
)
Quickstart Guardrails docs Route your traffic Forge (OSS) GitHub

Works with the OpenAI or Anthropic client you already ship, coding agents (Cursor, Claude Code, Cascade), Azure Foundry and other OpenAI-compatible endpoints, and new Python agents from Kimss Forge.

Pricing

Unlimited workspace members. Priced on governed requests, not per model token. Inference on your vaulted endpoints remains your provider bill.

PlanPriceNotes
Production $49 / mo 14-day trial (full Production features, no card)
Scale $199 / mo 1M governed requests
Enterprise Custom Volume, SSO / SCIM (Scale and Enterprise) packaging, procurement

Governed request: register, report, and gateway-routed calls the control plane governs. Not your provider’s model-token invoice or seat licenses. Full pricing →

Start with the kill-switch drill

Start 14-day Production trial Documentation

14 days of full Production features. No credit card required.