Enterprise AI governance & accountability
Now in enterprise pilotsYour AI agents run anywhere. Govern their model calls in one place.
IntSen helps enterprises control model access, enforce safety policies, evaluate agent quality, track execution and manage AI spending—all through one governed gateway.
Keep your agents. Keep your infrastructure.
Your apps & agents
IntSen AI Gateway
POST /openai/v1/chat/completions
- waiting for a model call…
Approved model provider
OpenAI · gpt-5.4-mini
Select a control to see what it does · synthetic example
The enterprise problem
AI is moving into production.
Accountability must move with it.
AI now reaches production through many teams, developers, platforms and agent frameworks. Each builds its own path to the model—so access, safety, quality, cost and ownership end up fragmented.
When something goes wrong, the questions are simple: Which agent was it? Was that model approved? Which policy applied? What did it do, how well, and at what cost? IntSen is built so you can answer them.
Model access
Teams hold their own provider keys and pick models ad hoc.
IntSen: Agents sign in with their own client; the gateway holds the keys and checks every model against the use case.
Safety controls
Each application implements—or skips—its own checks.
IntSen: Guardrails configured once per use case and agent, applied on every governed call.
Quality checks
Quality is judged by anecdote after something goes wrong.
IntSen: Live scores on real turns and golden tests that gate releases in CI.
Cost visibility
The provider invoice shows totals, not who spent them.
IntSen: Cost per request and per turn, rolled up to agent, use case and team.
Ownership
Nobody can say who owns an agent or why it exists.
IntSen: Every use case and agent is registered with named owners and a stated purpose.
Operational evidence
Logs are spread across apps, and prompts are rarely kept.
IntSen: Requests, verdicts, turns and scores recorded in one place, under a capture policy you set.
Govern the model call.
Understand the agent turn.
Account for the outcome.
The platform
One governed gateway.
Five layers of accountability.
A gateway routes traffic. IntSen ties every call to a registered use case, an accountable owner, an agent and a turn—so each one is controlled, checked, traced, measured and costed.
Control
Every agent signs in with its own OAuth client and belongs to a registered use case with named owners. The gateway checks the client, use case, provider, model and data class before a call leaves your network.
Model access by agent
| Agent | Data class | gpt-5.4-mini | gpt-4.1-mini | gpt-5.4 |
|---|---|---|---|---|
| Fleet Service Advisor | confidential | allowed | allowed | denied |
| Support Copilot | internal | allowed | denied | denied |
| Contract Q&A | restricted | denied | denied | allowed |
Illustrative product scenario — synthetic data
How it works
Keep your agent.
Add the governance.
Describe the use case and the agent in YAML
A Registration says which models the use case may use, how sensitive its data is and what it may spend. An Agent names its owners, its OAuth client and its per-turn limits. Apply both with intsenctl; a dry run shows the change first.
agent.yaml
apiVersion: governance.ai.intsen.com/v1kind: Agentmetadata: name: fleet-service-advisor namespace: field-servicespec: description: Diagnoses equipment issues for technicians. owners: [ { email: field-ai-owners@example.com } ] registration: field-service-assistant-prod clientIds: [ fleet-advisor-prod ] tasks: limits: { maxCostUsdPerTask: 0.50, maxDurationSeconds: 900 }Agent tracing
From a model call to an accountable agent turn.
A field-service assistant answers a technician's question. It calls the model, the model asks for an inventory lookup, the agent runs it and sends back the result, and the model answers. IntSen correlates everything that passes through the gateway into one turn.
Agent turn
Fleet Service Advisor · turn 2
- Duration
- 3.6s
- Calls
- 2
- Cost
- $0.0042
- Quality
- 92
Model asks for a tool
The model's response contains a tool call. IntSen reads it from the response body; the agent will run it.
- tool
- check_inventory
- call_id
- call_7f3a
- arguments
- { part: "PS-4410 pump seal", site: "Dallas" }
- finish_reason
- tool_calls
- output tokens
- 46
Illustrative product scenario — synthetic data
Use ↑ ↓ to move between steps
The lookup itself runs in your agent's environment. IntSen sees the model's request for it and the result your agent returns to the model—not the execution in between.
Quality and compliance
Don't just monitor AI.
Measure how well it performs.
Three distinct mechanisms, each with its own timing and purpose.
During the request
Guardrails
Controls that act on governed model calls: record, mask or block inputs, tool results and replies.
- Prompt injection, personal data, secrets, harmful content
- Your rules in plain English, or your own policy webhook
- Task-level checks across a whole turn
After the turn and in CI
Evaluations
Quality scoring and regression testing against thresholds you set.
- Live scores on a sample of real turns
- Golden test suites run from your CI pipeline
- Release gates on pass rate; replay on new models
After the turn
Compliance assessments
Configured post-turn reviews of completed agent activity—not a regulatory certification.
- Sensitive data, toxicity, safety, prompt attacks, off-purpose use
- Review queue for owners to triage findings
- Critical alerts and daily summaries
Spend intelligence
Know the cost of every turn—not just the monthly bill.
Usage is attributed from the model call up to the team that owns it. Select a level to see how it rolls up.
Agent
fleet-service-advisor
$615
Monthly budget $1,500 · alert when exceeded
Guardrail model checks: $18 · sub-agents: $44
Illustrative product scenario — synthetic data
Who it's for
Built for everyone accountable for enterprise AI.
The challenge
AI initiatives are multiplying across teams, frameworks and vendors faster than anyone can keep a consistent view of them.
One place to understand and govern your enterprise AI.
Explore the AI control planeOutcomes
- Every governed agent and use case is registered, with named owners
- Consistent model access and safety controls across teams
- Quality and spend visible per agent, not just per provider bill
Relevant capabilities
Industries
Govern AI where the stakes are real.
Where AI meets customers, technicians and regulated processes, the same questions of access, safety, quality and cost apply.
Trust
Built around control, evidence and enterprise ownership.
IntSen is designed so that every governed call is attributable, every decision is recorded, and the limits of what we see are stated plainly.
Authenticated model access
OAuth client credentials for every app and agent; unregistered callers are refused.
Policy enforcement
Access, guardrails and budgets enforced in the request path, with a refusal code for every denial.
Credential handling
Provider keys stay with the gateway and are injected per call. Apps never hold them.
Data capture policies
Body capture, retention and personal-data redaction set per use case.
Audit records
Requests, verdicts, turns, scores and costs kept as evidence for investigation.
Access and ownership
Named owners, approvals and change history for use cases and agents.
Clear integration boundaries
We state what the gateway sees—and what needs your own instrumentation.
Enterprise FAQ
Straight answers.
Including what IntSen does not do.
What exactly is IntSen?
IntSen is an enterprise AI governance and accountability platform. Your applications and agents send their model calls through the IntSen AI Gateway. IntSen checks who is calling and which model they may use, applies the guardrails and budgets you configured, groups calls into agent turns, scores quality and records the evidence—all in one place.
Does IntSen run or host our agents?
No. Your agents keep running in your own infrastructure, on the framework you already use. IntSen never hosts, deploys or edits them. It governs the model calls they route through its gateway.
Can we use our existing frameworks?
Yes, if the framework's model client lets you set a base URL and request headers—which LangGraph, the OpenAI Agents SDK, Semantic Kernel, Strands, CrewAI and plain SDK code all do. Your agent logic and tools stay unchanged.
How do we connect an agent?
Write two short YAML files—a Registration for the use case and an Agent for the agent—and apply them with intsenctl. Then change the model client's base URL to the gateway, sign in with the agent's OAuth client, and add a registration header and a new task id for each user message.
Which AI model providers are supported today?
The first release supports OpenAI: chat completions, the Responses API and embeddings, including streaming. Azure OpenAI and Anthropic are planned next. If you depend on another provider, tell us during your demo so we can discuss timing.
Does IntSen need a proprietary SDK?
No. The core integration is a base URL, an OAuth token and headers. An optional helper package makes it easier to run golden evaluation tests from CI, but your agent does not need it to be governed.
What can IntSen observe?
Every model call that passes through the gateway: the caller's identity, use case, agent and turn; the model, tokens, cost, latency and status; guardrail verdicts; the tool calls the model requested and the tool results the agent sent back to the model; and, when body capture is on, the request and response content.
What cannot IntSen observe?
Anything that does not pass through the gateway. That includes work your agent does before or between model calls (such as retrieval queries), tool executions themselves, actions whose results are never returned to the model, retries handled in your code, the exact answer shown to the user if your app changes it, and calls that bypass IntSen with a direct provider key.
How do guardrails work?
Guardrails run inside the governed request. Input checks run before the provider is called; output checks run on the reply, after it completes or during streaming if you switch that on. Each check can record, mask (for personal data) or block. Task-level checks look across a whole turn, for example personal data building up across several calls.
What happens if a policy engine fails?
Access decisions fail closed: if the gateway cannot confirm who is calling and what they may use, the call is refused. Guardrail checks fail open by default: if a check errors or times out, the call continues and the failure is recorded, so an outage in one check does not take your agents down. A stricter fail-closed setting for guardrails is designed; confirm its availability for your pilot.
Where are prompts and responses stored?
Request records, verdicts and costs are stored in IntSen's database. Request and response bodies are stored in object storage only when body capture is on for the use case, for the retention period you set, with personal data redaction available. Hosting location and deployment model are agreed with you during the pilot.
How does IntSen manage personal data?
Each use case declares its maximum data class and its capture policy: whether bodies are stored, for how long, and whether personal data is redacted. Guardrails can mask personal data before it reaches the model. End-user ids are stored only as a hash, and guardrail results store categories, never the content they found.
Can IntSen enforce budgets?
Yes. Use cases and agents can have monthly budgets that alert or deny when exceeded, and a request can have a maximum cost. Each turn can have cost, duration and call limits; when a turn goes over, the gateway refuses its next call. Budget alerts fire at 50, 80 and 100 percent.
How are agent evaluations performed?
Live evaluations score a sample of real turns with judge models against thresholds you set, such as goal completion and context adherence. Golden tests run scripted conversations from your CI pipeline with assertions on tool calls, text and judged criteria, and fail the build below your pass rate. Judge calls also go through the gateway and are billed separately from your agent's own cost.
How is IntSen different from an ordinary AI gateway?
A gateway routes and meters requests. IntSen uses the gateway as the single point of control, then ties every call to a registered use case, an accountable owner, an agent and a turn—so access, safety, quality, compliance and cost can be governed and investigated together, not in separate tools.
Ready to make your enterprise AI accountable?
See how IntSen can help your teams govern access, safety, quality and spending across the AI applications and agents you already run.