ON-PREMISES · EVERY MODEL YOU RENT OR OWN
Runtime governance for AI agents.

Where enterprise AI is going
Owned intelligence, governed from the first call.
Enterprises will rent some intelligence and own more of it.
Hybrid today
Frontier models in a provider's cloud. Open-weight models on hardware you own. Specialized models and a cache for repeat work. Four or five at once.
Hybrid tomorrow
Models change every quarter, and a provider or a government can switch one off. Every model has to be hot-swappable. When one goes dark, the work fails over and the application never notices.
Sourced by workload
Each workload goes to the intelligence that fits its data, its risk and its cost. The unit that matters is cost per successful workload.
APERION future-proofs the investment. Do not let the model provider become the architecture.
Why APERION →The problem
Every new model adds a seam. Agents find them at machine speed.
Diversity
Four or five models at once, rented and owned. Each provider ships its own agent framework, guardrails and console, built first for its own models.
Complexity
Split across providers, you run five policies and five logs. Asked who authorized an action and why it ran where it ran, you get five partial answers.
Speed
Agents act on a person's authority at machine speed and test every limit. With the payments API on its allowlist, an agent can send a $50,000 wire nobody approved, and every access check passes.
APERION closes the seams from one control point inside your walls. It sits in the path between your agents and every model and tool they call, rented or owned, and binds each action to the authority a person delegated.
What Smartflow did
An agent tried to wire $50,000 nobody approved.
It got as far as the policy. One MCP call, fifteen seconds, and four things happened before the money could move.
-
01
Checks the agent's behavior.
Every argument in the call, against policy, before anything executes.
-
02
Escalates to the human in the loop.
The named person whose authority the agent is using, not a queue.
-
03
Proceeds only after verification.
A live face check, at the assurance the risk calls for.
-
04
Records the whole thing.
Examiner-ready hash-chained entry.
Autonomous agents in the wild
Can you name the human behind every model call your agents made yesterday?
Most enterprises cannot, and they find out while looking at a spend report. To attribute a call to a business unit, something has to sit in the path and read it. Once it does, the harder question becomes answerable too: which verified human was this agent acting for, what did it send, and what came back.
Your identity stack was built for people. Agents are not people.
1
question from
one person
40
unattended
model calls
Thirty-nine of those forty happen with nobody watching.
Chat scales with headcount. Agents scale with tasks, and every task fans out into retrieval, reasoning, tool calls and retries.
One control point, three questions
The questions every agent program has to answer.
For the CEO
Can we put agents on real work and still answer for what they did?
Yes, when every action traces to a person. APERION sits in the path of every model and tool call your agents make, keeps the accountable human in each high-risk decision, and records who decided.
For the CISO
When an agent reaches past its authority, who decides?
The person whose authority it is using. The action pauses in the path and goes back to that person, verified through the proofing you already run, at an assurance that scales with the risk. Policy runs on every prompt, response and MCP tool call.
For the CFO
What did our agents cost, and who did they act for?
Every model call is metered, routed and cached at the same control point that enforces policy, so cost lands on a business unit and a person. One deployment, on-premises, across every model you rent or own.
PROOF IN PRODUCTION
THE TRUST FABRIC
Audit & Evidence
“Can we prove what happened to a regulator?”
Runtime Governance
“What is this agent authorized to do, and who decides when it exceeds that?”
Access Governance
Okta · Entra · Active Directory · Veza · SGNL
“What is the human allowed to do?”
Verified-human root
NIST IAL2/AAL2 · your proofing provider, enforced by Smartflow
“Who is the actual human?”
Agent identity
Bound to the verified human
“What identity does the agent carry, and on whose behalf?”
You keep the identity and access you already run, Okta, Entra, AD, Veza.
APERION governs the agent on top of it, from the verified human to the regulator-ready record.
AGENT ACTION
Delete production database
HIGH RISK
Held, awaiting a decision
VERIFIED HUMAN
Cleared by the accountable human
VERIFY
Every agent acts on a named person's authority. When it reaches past that authority, the action pauses in the path and goes back to that person, through the proofing you already run, at an assurance that scales with the risk: a push to their phone for a routine action, a live face check for a wire. The record shows who decided.
PROTECT
Shield stops destructive tool calls before they execute.
Shield stops destructive MCP tool calls before the database, repository, or filesystem receives them.


Where APERION sits
How APERION compares, by category.
Most enterprises run more than one of these. APERION composes with the identity systems you already run. What it adds is the decision by the accountable human, and the record.
| AI gateway | Guardrail library | Agent platform | APERION | |
|---|---|---|---|---|
| What it does | Routes and observes model traffic. | Filters prompts and responses inside one application. | Builds, runs and manages agents on its own platform. | Enforces policy on every prompt, response and tool call, for every agent and every model you rent or own. |
| Where it runs | In front of the model providers. | Inside the application's code. | Inside the platform, for the agents connected to it. | In the path between your agents and every model and tool, on-premises. |
| Who decides a high-risk action | A configured rule. | A rule in code. | An approval step inside the platform, where one exists. | The person whose authority the agent is using, verified at the moment of risk. |
| The record | Request logs. | Whatever the application logs. | The platform's activity log. | A tamper-evident, hash-chained record an examiner can follow from the policy to the person. |
Capabilities
What runs in the path.
Compiled Enforcement Path
Rust-based infrastructure. Not a Python library in the request path. Infrastructure-grade performance for production workloads.
Semantic Caching
Four-phase BERT semantic cache. Hit rates depend on the workload, so we measure them on your own traffic during a scoped POC.
On-Premises Deployment
Runs in your data center or private cloud. No cloud dependency. No PyPI supply chain risk. No third-party data exposure.
Identity-Aware Governance
Every AI interaction authenticated against your enterprise IdP over OIDC. Composes with Entra ID, Okta, SAML and Kerberos single sign-on. Per-user audit trails tied to real identities.
Inline Policy Enforcement
No-code compliance engine. Policies enforced before prompts reach any model. EU AI Act, NIST AI RMF, FINRA, HIPAA mapping.
MCP Proxy Governance
Inline governance for agent-to-agent workflows. As agentic AI proliferates, MCP servers are the new attack surface. Smartflow governs them.
Questions
Runtime governance for AI agents, answered.
What is runtime governance for AI agents?
Runtime governance enforces policy on an AI agent's actions while they happen: on every prompt, response and tool call, in the path between the agent and the models and tools it uses. APERION adds the accountable human to each high-risk decision and captures auditable evidence for every decision.
Is APERION an AI gateway?
APERION sits where a gateway sits, in the path of every model and tool call. A gateway routes and observes that traffic. APERION enforces policy on it, sends high-risk actions to the person whose authority the agent is using, and records who decided.
Who decides when an agent exceeds its authority?
The person whose authority the agent is using. The action pauses in the path and goes back to that person, verified through your proofing provider at NIST IAL2/AAL2, at an assurance that scales with the risk: a push to their phone for a routine action, a live face check for a wire. The record shows who decided.
Does APERION run on-premises?
Yes. Smartflow runs in your data center or private cloud and is Kubernetes-native. It governs every model you rent or own, frontier models in a provider's cloud and open-weight models on your own hardware, from one control point inside your walls. No prompt, response or cached artifact traverses APERION infrastructure.
Which identity systems does APERION work with?
The ones you already run. Every AI interaction is authenticated against your enterprise identity provider over OIDC. APERION composes with Okta, Entra ID, Active Directory, Veza and SGNL, and with SAML and Kerberos single sign-on.
What does an examiner receive?
A tamper-evident, hash-chained record of every agent action: the policy that applied, the person whose authority the agent used, who decided and what happened. Compass verifies the evidence chain, scores the current posture and produces a report locally.
What is owned intelligence?
Owned intelligence is AI an enterprise runs on infrastructure it controls, alongside the frontier models it rents. Enterprises will rent some intelligence and own more of it. APERION governs both from one control point, from the first call, so every model stays hot-swappable and the policy and the evidence stay with the enterprise.
More questions
Runtime governance, AI gateways and firewalls, agent identity, MCP tool-call governance and compliance evidence, in one place.
All questions →Name the human behind every model call.
One workflow, in your environment, on your infrastructure. Our forward-deployed engineers embed with your team and have it in production in under 90 days.
The runtime governance layer for enterprise AI agents in regulated industries.
Products
Solutions
© 2026 APERION, Inc.
