Truth in IT
    • Sign In
    • Register
        • Videos
        • Channels
        • Pages
        • Galleries
        • News
        • Events
        • All
Truth in IT Truth in IT
  • Data Management ▼
    • Converged Infrastructure
    • DevOps
    • Networking
    • Storage
    • Virtualization
  • Cybersecurity ▼
    • Application Security
    • Backup & Recovery
    • Data Security
    • Identity & Access Management (IAM)
    • Zero Trust
    • Compliance & GRC
    • Endpoint Security
  • Cloud ▼
    • Hybrid Cloud
    • Private Cloud
    • Public Cloud
  • Webinar Library
  • TiPs
  • DRAW

Runtime Security for AI Agents with MCP Gateway

Saviynt
08/03/2026
0 (0%)
Share
  • Comments
  • Download
  • Transcript
Report Like Favorite
  • Share/Embed
  • Email
Link
Embed

Transcript


AI Agents. This one is going to be my favorite. You all would have heard the term agents are autonomous, they learn the reason they adapt, which means that as you define, as you create these agents, you are going to define a scope or boundary or permission sets, but agents are not going to honor them. That creates a problem statement which every organization is thinking and designing for, which means when an agent is interacting and accessing your data from enterprise applications at runtime, you have to monitor, you have to understand if they are deviating from their original intent and purpose and make sure that they are not doing any catastrophic transactions to your enterprise applications. How do you do that? Let us take a look. As you build your agents, these could be of different types. You will have your IT ops agent, you could have a marketing agent, you could have a finance agent, you could have an HR agent. Now as you continue to build these agents, the purpose for these agents is to talk to enterprise applications. This could be your SaaS apps, ERP applications, infrastructure as a service applications, it could be databases, it could be directory systems and any and every other application which you can think of. Now as these applications are interacting or getting interacted and consumed by agents, the agents are going to interact using tools, APIs, MCP interfaces or model context protocol interfaces. The question is how do you define a security policy which gets enforced in real time for every agentic transaction happening and this is where Savian's MCP gateway or access gateway comes in. This is an MCP interface from Savian's access gateway. It has got two parts. One is an MCP interface and the other one is a policy engine. As I mentioned, Savian's access gateway is nothing but an MCP server which means you can consume this entire component as an MCP endpoint to your agents. Now what does that MCP interface gives you? One it offers you a tool registry which means any and every tool of your underlying applications can be exposed, controlled and defined what all are going to be available for the agents to consume, number one. Number two are your action interceptors. Every tool call by the agent to an underlying application gets mapped to an underlying API call for that application as well. And last but not the least is your resource mapping which also plays a very important role. The point being is each and every API call has to be mapped to the underlying assets resources in the underlying application as well. So that is the first component of what the Savian's access gateway exposes from underlying application for the agents to consume, map it to their intent, define what tools and API calls they can consume and they can invoke on the target application. The second part of your access gateway is all about policy evaluation. If you have an as an organization have a policy stating that anytime a rogue agent and orphan agent or an unregistered agent should never be able to perform an agentic transaction you can enforce that and you should be enforcing that at the gateway layer. Very important aspect here is intent analysis, this is an interesting one. Try this with your agents which you are comfortable with, write in your cloud code Amazon queue saying that go ahead and clean up my CRM records or Jira task. What you would understand and see that is that at times a large language model understands these NLP prompts to be done in a much different way. For you as a user your intent could be as simple as go ahead and optimize my records in Jira, Google drive or CRM systems whereas an agent is being instructed by a large language model to go ahead and delete all your records. So at any given point of time when an agent is being tasked by a human or by an agent to a sub agent understanding the intent becomes extremely important and imperative and that is why one of the four most important aspects of savings gateway or access gateway is to understand analyze that intent and map it to the actual transaction the agent is going to perform on a particular target system. And the last one here in this case is going to be your decision plus audit which means at any and every point of time what is the final decision which this component is going to have for this agent to perform on a target application because this basically drives the different outcomes the gateway can have and it is as simple as either your transaction is going to be allowed or it is going to be blocked. For example if the agent's intent is to be going in and exporting all your data outside your CRM system and if your policy says that such kind of data exfiltration is not allowed which ideally it should be and those transactions get blocked. You can also have a human in the loop outcome what if the agent is trying to delete a mass set of records old and archived records. It may be a legitimate reason but you still want a human in the loop to go ahead and make sure that it gets approved. And last but not the least you log everything to have provenance in this complex identity chaining workflow scenarios. So at any given point of time when you have an access gateway what do you really get? You get runtime enforcement of access and policies. You can define what the access for your agents at design time is but those access can be tweaked, changed, modified at runtime depending on what the agent's intent is as well as you can enforce your corporate policies like rogue agents should never be performing an agentic transactions number 1. Number 2 you eliminate chaining risk see it is very important to understand when you have multi-agent systems talking to each other it is very common that if one of the agents has gone rogue it can create a massive risk for the other agent identities in your ecosystem and that is why having a system wherein somebody like an a savings access gateway is monitoring every agentic transaction becomes paramount to eliminate such kind of chaining risk in your ecosystem. The third one in this case is you having least privileged access recommendations for your agents. Our original goal was also to ensure that agents never have residual access standing access or high privileged access permanently and access gateway allows you to constantly monitor and remove any such unused as well as access which the agents have never been using or it is an outlier access into this ecosystem and last but not the least this entire interface as I mentioned is an MCP native interface which means it is made for agentic systems which are built on the principles of model context protocol so that you can do this at scale with all your new technologies which are coming up. This is what savings access gateway brings to the table by empowering organizations to monitor and enforce their policies at run time for every agentic transactions going and happening in their ecosystem. Friends again it is very imperative that design time controls are not sufficient for AI agents you have to have a run time enforcement engine and that is what savings access gateway is built for. I hope you found this session useful I am very excited to talk about the on behalf of access flows and autonomous workflows and the role of savings gateway in my next shock talk. So looking forward to having you there till then thank you once again for giving me your time and attending this session.

TL;DR

  • AI agents are autonomous and don't honor predefined permission boundaries, requiring runtime monitoring to prevent them from deviating from their original intent and performing catastrophic transactions on enterprise applications.
  • Saviynt's Access Gateway functions as an MCP server that provides a tool registry, action interceptors, and resource mapping, combined with a policy engine that enforces security policies in real-time for every agentic transaction.
  • The gateway's intent analysis capability prevents dangerous misinterpretations—such as when an agent interprets "clean up records" as a delete operation rather than optimization—by analyzing natural language prompts before execution.
  • Organizations gain runtime policy enforcement, elimination of identity chaining risk in multi-agent systems, least privilege access recommendations, and complete audit logging through an MCP-native interface designed for scale.
  • Design-time controls are insufficient for AI agents; runtime enforcement is essential to monitor agent behavior, block rogue agents, and ensure agents never maintain residual standing access or excessive privileges permanently.

The Challenge of Autonomous Agent Security

AI agents are fundamentally different from traditional applications because they learn, reason, and adapt autonomously. While organizations can define initial scope, boundaries, and permission sets for agents, these autonomous systems don't necessarily honor those constraints. This creates a critical security challenge: when agents interact with enterprise applications at runtime—accessing data from SaaS apps, ERP systems, databases, and infrastructure services—organizations must monitor whether agents are deviating from their original intent and prevent catastrophic transactions. The problem becomes more complex in multi-agent environments where IT ops, marketing, finance, and HR agents all interact with different enterprise systems through tools, APIs, and Model Context Protocol (MCP) interfaces.

Saviynt's MCP Gateway Architecture

Saviynt's Access Gateway functions as an MCP server with two core components: an MCP interface and a policy engine. The MCP interface provides a tool registry that controls which application tools are available for agent consumption, action interceptors that map every agent tool call to underlying API calls, and resource mapping that connects API calls to specific assets in target applications. The policy engine handles four critical functions: blocking rogue or unregistered agents, analyzing intent to prevent misinterpretation of natural language prompts, enforcing corporate policies at runtime, and providing decision outcomes (allow, block, or human-in-the-loop approval) with complete audit logging. This architecture enables organizations to enforce security policies in real-time for every agentic transaction, addressing the gap between design-time controls and runtime agent behavior.

Key Benefits and MCP-Native Approach

The Access Gateway delivers runtime enforcement of access policies that can be dynamically adjusted based on agent intent, eliminates identity chaining risk in multi-agent systems where one compromised agent could impact others, and provides least privilege access recommendations by monitoring unused or outlier permissions. A critical capability is intent analysis—for example, when a user asks an agent to "clean up CRM records," the large language model might interpret this as a delete operation rather than optimization. The gateway analyzes these intents before execution to prevent unintended actions. Built as an MCP-native interface, the solution is designed specifically for agentic systems following Model Context Protocol principles, enabling organizations to scale security controls across emerging AI agent technologies while maintaining complete provenance through comprehensive audit logging of all agentic transactions.

Chapters

0:00 - Introduction: The Agent Security Challenge
1:01 - Agent Types and Enterprise Application Landscape
2:23 - Saviynt's MCP Gateway Architecture
3:05 - MCP Interface Components
4:28 - Policy Engine and Intent Analysis
6:12 - Decision Outcomes and Audit Logging
7:45 - Key Benefits of Runtime Enforcement
10:09 - Closing: Design-Time vs Runtime Controls

Key Quotes

0:15 "You all would have heard the term agents are autonomous, they learn the reason they adapt, which means that as you define, as you create these agents, you are going to define a scope or boundary or permission sets, but agents are not going to honor them."
5:12 "Try this with your agents which you are comfortable with, write in your cloud code Amazon queue saying that go ahead and clean up my CRM records or Jira task. What you would understand and see that is that at times a large language model understands these NLP prompts to be done in a much different way."
5:32 "For you as a user your intent could be as simple as go ahead and optimize my records in Jira, Google drive or CRM systems whereas an agent is being instructed by a large language model to go ahead and delete all your records."
8:28 "It is very common that if one of the agents has gone rogue it can create a massive risk for the other agent identities in your ecosystem and that is why having a system wherein somebody like an a savings access gateway is monitoring every agentic transaction becomes paramount to eliminate such kind of chaining risk in your ecosystem."
9:18 "Our original goal was also to ensure that agents never have residual access standing access or high privileged access permanently and access gateway allows you to constantly monitor and remove any such unused as well as access which the agents have never been using or it is an outlier access into this ecosystem."

FAQ

Why can't organizations rely on design-time access controls for AI agents?

AI agents are autonomous systems that learn, reason, and adapt, which means they don't necessarily honor the initial scope, boundaries, or permission sets defined when they're created. As agents interact with enterprise applications at runtime, they may deviate from their original intent, requiring real-time monitoring and policy enforcement to prevent catastrophic transactions.

What is the Model Context Protocol (MCP) and why does it matter for agent security?

Model Context Protocol (MCP) is an interface standard that agents use to interact with enterprise applications. Saviynt's Access Gateway is built as an MCP-native server, meaning it's specifically designed for agentic systems following MCP principles. This allows organizations to implement security controls at scale across emerging AI agent technologies using a standardized protocol.

How does the Access Gateway prevent agents from performing unintended actions?

The gateway includes intent analysis capabilities that examine what an agent is actually trying to do before allowing the transaction. For example, if a user asks an agent to "clean up" records, the large language model might interpret this as a delete operation. The gateway analyzes the intent, compares it to corporate policies, and can block the action, allow it, or require human approval before execution.


Categories:
  • » Cybersecurity » Zero Trust
  • » Data Protection
Channels:
News:
Events:
Tags:
  • Identity & Access
  • AI & Machine Learning
  • Security Operations
  • Technical Deep Dive
  • Zero Trust
  • AI Agent Security
  • Model Context Protocol
  • MCP
  • Runtime Policy Enforcement
  • Identity and Access Management
  • Intent Analysis
  • Multi-Agent Systems
  • Least Privilege Access
Show more Show less

Browse videos

  • Related
  • Featured
  • By date
  • Most viewed
  • Top rated
  •  

              Video's comments: Runtime Security for AI Agents with MCP Gateway

              Industry Events (Sponsor Hosted)

              • Aug
                03

                Discover DLP Memories: The ever-evolving triage agent enhancing efficiency each shift.

                08/03/202611:00 AM ET
                • Aug
                  06

                  Safeguarding Sensitive Data in the Age of AI Platforms

                  08/06/202604:00 AM ET
                  • Aug
                    06

                    AI Agents Revolutionizing Identity Attacks: Same Tactics, Enhanced Speed

                    08/06/202602:00 PM ET
                    More events

                    Upcoming Webinar Calendar

                    • 08/03/2026
                      11:00 AM
                      08/03/2026
                      Discover DLP Memories: The ever-evolving triage agent enhancing efficiency each shift.
                      https://www.truthinit.com/index.php/channel/2062/discover-dlp-memories-the-ever-evolving-triage-agent-enhancing-efficiency-each-shift/
                    • 08/06/2026
                      04:00 AM
                      08/06/2026
                      Safeguarding Sensitive Data in the Age of AI Platforms
                      https://www.truthinit.com/index.php/channel/2058/safeguarding-sensitive-data-in-the-age-of-ai-platforms/
                    • 08/06/2026
                      02:00 PM
                      08/06/2026
                      AI Agents Revolutionizing Identity Attacks: Same Tactics, Enhanced Speed
                      https://www.truthinit.com/index.php/channel/2064/ai-agents-revolutionizing-identity-attacks-same-tactics-enhanced-speed/
                    • 08/13/2026
                      12:00 PM
                      08/13/2026
                      Harnessing AI for Secure Innovation in the Enterprise with Netskope & Omada
                      https://www.truthinit.com/index.php/channel/2065/harnessing-ai-for-secure-innovation-in-the-enterprise-with-netskope-omada/
                    • 08/19/2026
                      12:00 PM
                      08/19/2026
                      Becoming Agent Ready: Insights and Strategies with Cyera
                      https://www.truthinit.com/index.php/channel/2036/becoming-agent-ready-insights-and-strategies-with-cyera/
                    • 09/02/2026
                      12:00 PM
                      09/02/2026
                      Unified Data Security in Action: Uncover, Analyze, and Resolve Threats
                      https://www.truthinit.com/index.php/channel/2045/unified-data-security-in-action-uncover-analyze-and-resolve-threats/
                    • 09/30/2026
                      04:00 AM
                      09/30/2026
                      AI Command Center: Optimizing Visibility and Control in Your Operations
                      https://www.truthinit.com/index.php/channel/2024/ai-command-center-optimizing-visibility-and-control-in-your-operations/
                    Truth in IT
                    • Sponsor
                    • About Us
                    • Terms of Service
                    • Privacy Policy
                    • Contact Us
                    • Preference Management
                    Desktop version
                    Standard version