Ship AI features fast without
Engineering teams want to ship AI features fast, but security reviews keep slowing them down. Igris enforces governance at the proxy layer, so you keep your existing OpenAI, Anthropic, or Google SDK code, satisfy every security requirement, and clear the review without a rewrite.
SDK Integration in Minutes
Security flags your AI feature before it ships. They want governance, audit logs, content scanning, the full list. You have already built the feature using the OpenAI, Anthropic, or Google SDK. It works. Now you are calculating how long a rewrite takes and whether the sprint is blown. The review is not even about the feature itself, it is about the infrastructure around it, and you are the one who has to fix it before anything goes to production.
There is no rewrite. Install the Igris SDK, point it at your Igris API key, and reference your connection in the model name. The base URL and API key swap transparently, every other line of your code stays exactly as it is. Adapters cover OpenAI, Anthropic, and Google SDKs. Custom headers carrying user IDs, trace IDs, and metadata flow through automatically. Three changes. The rest of your code does not know anything happened.
The security requirement gets satisfied at the proxy layer. Your feature ships on the original timeline. The sprint does not move, and the next security review starts with AI governance already in place.
PII Protection Without Code Changes
Users paste sensitive data into AI features constantly, credit card numbers, social security numbers, personal details dropped straight into the chat input. You know it needs to be handled before it reaches the LLM. Building LLM PII protection from scratch means regex patterns, false positives, compliance review cycles, and ongoing maintenance, all before the feature is allowed to ship. It is a rabbit hole that has nothing to do with the feature you were actually hired to build.
Define a content guard policy in Igris with detectors for the data types you care about, credit cards, SSNs, email addresses, and 20+ others, and set the action to redact. Igris replaces sensitive values with masked text before the prompt leaves your network. It also inspects LLM responses for leaked PII before they return to the user. You write zero PII handling code. Every redaction is logged in the audit trail with details of exactly what was matched and when.
PII protection ships with the feature, not weeks after it. You did not build a detection pipeline. Compliance has a full log. The feature clears the security review without a hold.
Debugging LLM Failures With Encrypted Body Logs
A user reports a wrong, confusing, or harmful output from your AI feature. To understand what happened, you need the actual prompt and response from that session. But you cannot dump raw request bodies into your logging stack, they contain user data, and you will open a compliance issue trying to debug a product one. So you guess. You add temporary logging. You try to reproduce it in staging with synthetic data and hope it is close enough. Half the time it is not, and you are still guessing a week later.
Switch on full content logging for the connection in Igris. Request and response bodies are encrypted with AES 256 GCM before storage, each with its own initialization vector. They are kept for a configurable retention period, 30 days by default, and an hourly sweeper permanently deletes anything that has expired. When you need to debug, decrypt and inspect the bodies through the API. No raw sensitive data sitting in your logging stack. No compliance risk from a debugging session.
You see exactly what the user sent and exactly what the LLM returned. You fix the bug from real data, not a reproduction attempt. When the retention window closes, the logs are gone, automatically, without anyone having to remember to clean them up.
Model Restriction and Cost Control for Dev Environments
It takes one afternoon of testing on a premium model to burn hundreds of dollars without noticing. Someone forgets to switch the model name back. A test script runs longer than expected. The bill shows up at the end of the month, nobody remembers exactly what ran, and now there is a conversation about being more careful. You start double checking the model name before every test run. You feel like you are being watched every time you spin something up. That is not a good way to work.
On your dev connection, define exactly which models are allowed, lightweight versions only, and the policy engine denies anything else with immediate feedback. Token guards cap input and output sizes to prevent runaway prompts. Budget rules alert on any call above $0.50 and hard block anything above $2.00. You know the moment you cross a line, before it compounds into something that shows up on a billing report three weeks later.
Dev testing stays cheap. Surprise bills stop happening. You can run tests freely knowing there is a hard ceiling in place, without auditing your own model config every single time before you hit run.
MCP Server Governance
Your product relies on MCP servers for database access, search, email, and code execution. Some of those tools are safe for agents to call freely. Others, command execution, file deletion, sending email on behalf of a user, are dangerous if an agent calls them unexpectedly, or if a manipulated input gets through. Right now there is no layer between your agent and those tools. Either everything is accessible, or you build your own allow and deny logic and maintain it yourself every time something changes. OWASP LLM Top 10 identifies excessive agency as a critical production risk in AI systems, MCP server governance addresses it directly at the infrastructure layer.
Define a policy for each individual tool on your MCP connection in Igris. Harmless tools such as document search and reading email get allowed. Destructive ones such as command execution and file deletion get denied. Sensitive tools such as sending email get allowed but are set to trigger an alert. The MCP proxy enforces these rules on every tool call, tracks which user or agent acted within each session, and logs every violation with the tool name, arguments, actor, and timestamp.
Agents get access to the tools they actually need. The dangerous ones are blocked at the proxy layer, not by guard logic you wrote and now own, not by hoping the agent stays within bounds. And when something unexpected happens, you have a full record of exactly what was called, by whom, and with what arguments.
Add governance to your AI feature in three changes
See how engineering teams drop in the Igris SDK, redact PII without code changes, and govern every MCP tool call in production.