DEV Community: Abhishek Kalu

Most AI Chatbots Send Customer Data Straight to the Model. Here's the Layer We Built to Stop It.

Abhishek Kalu — Thu, 22 Oct 2026 17:19:46 +0000

The pattern we kept seeing

We've talked with a lot of teams shipping AI features. Support chatbots, internal assistants, agents wired into customer records. Different products, different stacks. And one thing kept showing up.
There was no security layer at all.

A user typed something into the chatbot. It went to the agent. The agent passed it to the LLM. Nothing in between looked at what was being sent. If a customer pasted their credit card number into a support chat, that number went to a third-party model, word for word. If someone tried to push the bot into misbehaving, nobody was watching.
Nobody built it this way on purpose. Teams were moving fast, the demo worked, and security was going to be "phase two." Phase two rarely shows up.

A checkpoint in the middle

So we asked a simple question. What if every LLM call had to pass through a checkpoint first?

That's the idea behind Igris. It sits between your application and the model, and every prompt goes through it. Igris reads the full prompt, checks it against your policies, and if anything breaks a rule, the call is blocked before it reaches the model.

Clean prompts go on to the model. Anything that breaks a rule is blocked or redacted, and every request is logged either way.

Your developers don't have to rebuild anything for this. Igris speaks the same API format as OpenAI, so the app keeps making LLM calls the way it always did. Each call just takes a short detour through a layer that knows your rules.

What the policies actually block

The policies themselves are practical. Most teams want the same short list kept away from the model:

Email addresses
Phone numbers and other contact details
Social Security numbers
Credit card numbers
Any other personal data your industry treats as sensitive

None of this is exotic. It's the data that turns an ordinary chatbot conversation into a compliance problem. When Igris finds it in a prompt, it can block the call outright or redact just the sensitive part, depending on how you set the policy.

When one user hammers the chatbot

Rules catch bad content. They don't catch bad behavior.

Picture one user firing message after message at a company's chatbot. Each message might look harmless on its own. Together they look like someone probing for a weakness, scraping answers, or running up the token bill.

Igris watches for that pattern. When a single user suddenly bombards a customer's AI with messages, it detects the anomaly and raises a flag, so the team can look into it before it turns into a real problem.

Log everything, and anomalies stand out

You can't spot strange behavior if you don't know what normal looks like. That's why Igris logs every request a user sends to our customer's AI. Every single one.

Those logs do two jobs. Day to day, they're the baseline that makes anomalies visible. And when something does go wrong, they're the record that shows who sent what, when, and what happened to it.

Protection in both directions

We think of this layer as protecting two sides at once.

On one side are your customers. The personal data they share with your chatbot shouldn't end up held by an AI agent. Igris stripped out the sensitive and confidential data before agents sees it. Igris can remove or redact the sensitive data and then send it to the agent.

On the other side is your company. The chatbot you put in front of the public shouldn't become something users can exploit. The same layer that checks what goes in also watches how people are using it.

What this looked like for one client

We have seen many companies where their user share sensitive data wihtout noticing that might be used for different purpose or user sometimes as for different user data where this problem get more interesting. Igris catch any sensitive data like credit card number, medical report numbers, SSN, email, phone number, etc. Igris give logs where all user queires are stored, flaged, or blocked.

Three questions to ask about your own AI app

If you're not sure whether your chatbot has a middle layer, these will tell you fast:

If a user pastes a credit card number into your chatbot, where does it go?
Would you know if one user sent hundreds of messages in a few minutes?
If a customer asked what your AI did with their data last week, could you show them?

If any answer is "I'm not sure," that's the gap.

Most of the teams we talk to aren't careless. They just never put anything between their users and the model. Adding that layer doesn't have to slow anyone down, and that's the reason we built Igris.

Want to see what's passing through your own AI app? Try Igris.

Scaling AI Security: From Single Agent to Enterprise Fleet

Abhishek Kalu — Thu, 22 Oct 2026 16:55:02 +0000

Your organization likely started with a single AI agent for a specific use case. Perhaps a customer service chatbot, a data analysis assistant, or an automation script for internal workflows. The project succeeded, delivered value, and proved that AI agents can transform operations. Now your teams are asking about deploying more agents across different departments and use cases. The challenge is that managing ten or hundred agents requires fundamentally different approach than what worked for one.

The reality is that manual governance approaches do not scale. Security reviews that worked for one agent become impossible when you have fifty. Individual approvals for every tool connection break down when teams deploy agents daily. Spreadsheets for tracking access and permissions cannot keep pace with automated systems. Your governance model that enabled first deployment becomes a bottleneck for growth.

Architecture Patterns for Scale

Distributed governance provides flexibility that centralized systems cannot match. Instead of routing every agent request through a single approval gateway, consider federated models where departments or teams maintain their own policy engines. These local engines evaluate requests against relevant rules and handle approvals for common cases autonomously, escalating only exceptions to central governance teams. This approach reduces bottlenecks while maintaining consistent standards across organization.

Hierarchical policies enable efficient rule management at scale. Rather than defining separate rules for every single agent, create policy hierarchies with base rules that apply universally, team-specific rules that build on top of base, and agent-specific exceptions for unique use cases. When you need to update a security requirement, change it once in the base policy and it applies to all agents automatically. This structure prevents rule explosion while allowing necessary customization.

Event-driven architectures support thousands of concurrent agents. Design your governance systems to handle agent actions as discrete events rather than holding connections open for real-time decision making. An agent requests access, governance system evaluates against policies, grants or denies access, logs the decision, and closes connection. This event-driven approach eliminates state management complexity and enables horizontal scaling across many agents without linear performance degradation.

Policy Management at Enterprise Scale

Policy inheritance prevents duplicate work and inconsistencies. Define master policies for common requirements that apply across your entire organization, then allow teams to define local policies that inherit from these masters. When you need to tighten a security control, update the master policy and all dependent policies automatically reflect the change. This approach saves time and ensures consistency while still allowing local customization for specific needs.

Automated policy testing catches regressions before they cause problems. Maintain a library of test scenarios that represent common agent behaviors and security requirements. Whenever a policy is created or modified, automatically run it through these tests to verify it behaves as expected. This testing prevents unintended policy changes from breaking legitimate agent operations while catching errors that security reviews might miss.

Policy versioning enables safe rollbacks and auditing. Every time a policy changes, create a new version with clear documentation of what changed and why. Keep previous versions active with deprecation warnings so that agents can transition gradually. When a new policy causes unexpected issues, you can quickly revert to previous version while you investigate and fix the problem. This approach reduces risk of policy changes while supporting compliance audits that track policy history.

Automation for Human Efficiency

Automated enforcement handles routine decisions that should not require human review. Implement automated approval workflows for common, low-risk scenarios like accessing public data sources, using standard tools, or operating within defined access boundaries. Reserve human review for genuinely novel situations, exceptions to policy, or high-risk actions like accessing sensitive customer data. This approach reduces review backlog while focusing human attention on cases that actually need it.

Automated monitoring provides continuous visibility without manual effort. Configure systems to automatically track metrics like number of active agents, policy violation rates, response times, and system health. Set up alerts for anomalous patterns that might indicate security issues or policy problems. Automated dashboards aggregate this data and present it to appropriate stakeholders without requiring manual report generation. This continuous visibility enables proactive management instead of reactive firefighting.

Automated remediation reduces response time for common issues. Implement self-healing mechanisms for routine problems like automatically revoking credentials when agents are decommissioned, rotating expired access tokens, or triggering incident response processes when threshold violations are detected. These automated responses handle the majority of routine incidents, letting your team focus on complex issues that require human judgment and decision making.

Multi-Tenant Considerations

Organizational boundaries require clear separation. Different business units may have different security requirements, data access needs, and compliance frameworks. Implement tenant isolation at your governance layer so that policies, monitoring data, and incident workflows are properly separated between departments or business units. This isolation prevents one team's policies from inadvertently affecting another and enables appropriate access controls for different regulatory environments.

Role-based access control scales more effectively than individual agent permissions. Define roles at organizational or team level rather than assigning permissions to each individual agent. Agents inherit permissions based on their role, department, or project assignment. When you need to change access for an entire class of agents, update the role once and all dependent agents automatically reflect the change. This approach reduces management overhead and ensures consistent access patterns across your agent fleet.

Environment-specific policies support development versus production needs. Your development, staging, and production environments likely have different security requirements. Development agents may need broad access for testing and debugging, while production agents should have strict, least-privilege access. Implement policy engines that can apply different rule sets based on environment context. This enables developers to work efficiently while production systems maintain strong security boundaries.

Performance Optimization

Batch processing reduces overhead compared to individual request handling. Design your governance systems to evaluate multiple policy checks or access requests together when possible rather than processing each one separately. Implement asynchronous processing for non-critical decisions so that agents do not block while governance systems evaluate requests. These performance optimizations ensure that governance does not become a bottleneck as your agent fleet scales to thousands or tens of thousands of concurrent operations.

Caching common decisions eliminates redundant processing. Cache the results of frequently accessed policy evaluations, authorization checks, or permission lookups. When an agent requests access to the same resource multiple times, return the cached result instead of recomputing it. Implement cache invalidation strategies that balance performance with security, such as time-based expiration or event-driven invalidation when policies change.

Connection pooling and load distribution manage resource utilization efficiently. Implement connection pools for communications between agents and your governance systems to avoid overhead of establishing new connections for every request. Distribute load across multiple governance instances or worker processes to prevent any single component from becoming a bottleneck. Monitor resource utilization and implement auto-scaling based on traffic patterns to handle peak loads without performance degradation.

Cost Management Strategies

Usage-based pricing aligns costs with actual consumption. Track detailed metrics about how your agents use governance services and infrastructure resources. Use this data to negotiate pricing models based on actual usage patterns rather than estimates. This approach prevents over-provisioning while ensuring you have capacity when you need it, creating more predictable and efficient cost management.

Resource allocation optimization reduces waste. Implement quotas and limits at multiple levels, including per agent, per team, and organization-wide. Monitor utilization patterns and right-size resources based on actual needs rather than peak projections. Automated resource reclamation decommissions agents or resources that have been inactive for defined periods, freeing capacity for active workloads and reducing unnecessary costs.

Multi-cloud or multi-region strategies provide cost optimization opportunities. Different regions or cloud providers may offer significantly different pricing for the same governance services. Implement abstraction layers that allow your governance systems to operate across multiple environments without being locked into a single provider. This flexibility enables you to choose the most cost-effective location or provider for each workload, reducing overall infrastructure costs.

Team and Access Control

Self-service governance reduces bottleneck on central teams. Implement portals where team leads can manage agents, policies, and access controls within their scope without requiring approval from central security or governance teams for routine changes. Central teams focus on defining standards, providing tools, and handling exceptions, while day-to-day management stays close to where work happens. This approach scales better because it distributes decision making across organization.

Delegated approval workflows enable local accountability. Define approval chains where team leads can approve certain types of changes within their authority boundaries. Implement automated routing of requests through appropriate approval chains based on change type, risk level, or resource impact. This delegation reduces bottlenecks on central teams while maintaining appropriate oversight and audit trails for all changes.

Just-in-time access provisioning reduces standing permissions. Instead of granting agents permanent access to all systems they might ever need, implement time-bound or use-case-scoped access grants. Agents request access when needed, governance systems evaluate the request against policies, and access is granted for the duration required. This approach reduces security surface by minimizing standing permissions while still enabling agents to function effectively.

Maturity Model and Roadmap

Start with foundational capabilities and add sophistication over time. Implement basic agent discovery, policy management, and monitoring in your first phase. Add automated enforcement, advanced analytics, and integration with existing systems in phase two. Build toward fully automated policy engines, predictive anomaly detection, and comprehensive incident response in phase three. This incremental approach allows your organization to gain value early while building toward advanced capabilities without attempting to implement everything at once.

Measure governance maturity to guide investment decisions. Define clear maturity levels from ad-hoc to optimized, with specific criteria and capabilities for each level. Regularly assess your current state against this model to identify gaps and prioritize investments. Communicate maturity progress to executives to demonstrate value and justify continued investment in governance capabilities.

Build toward standardization while maintaining flexibility for unique needs. As you scale, certain processes benefit from standardization across your organization. Document best practices and create templates for common agent types, policy patterns, and deployment scenarios. At the same time, maintain flexibility for departments or teams with truly unique requirements that justify custom approaches. This balance between standardization and flexibility enables efficiency without constraining innovation.

The organizations that successfully scale AI governance do not try to implement everything at once. They start with foundational capabilities, learn from early deployments, and gradually build sophistication over time. They balance automation with human oversight, standardization with flexibility, and performance with security. This measured approach enables confident growth from single-agent deployments to enterprise-scale AI fleets without creating bottlenecks, vulnerabilities, or operational chaos.