Latest / What the Hoot! / AgentIQ: Governing Autonomous AI Agents from the Inside

Transcript

AgentIQ: Governing Autonomous AI Agents from the Inside · What the Hoot!

• 0:09
  SPEAKER_01: Hello everyone and welcome.
• 0:10
  SPEAKER_01: Thank you again for joining us today.
• 0:12
  SPEAKER_01: AI has moved incredibly quickly from something that can answer questions to something that can actually take action.
• 0:17
  SPEAKER_01: Agents can now call APIs, they can access enterprise systems, they can execute workflows, they move data, they approve requests, they initiate transactions, and make decisions with surprisingly little human involvement.
• 0:28
  SPEAKER_01: And that creates a very different question for the enterprise.
• 0:31
  SPEAKER_01: It's no longer just can we build an agent that does this?
• 0:35
  SPEAKER_01: The question is becoming how do we let that agent act autonomously while still knowing exactly what it's doing, controlling what is allowed to do, protecting sensitive information, managing costs, and providing afterwards why a particular action happened.
• 0:51
  SPEAKER_01: That is what we're going to explore today.
• 0:53
  SPEAKER_01: And joining me are two people who have been closely involved in building MeshIQ's approach to this problem.
• 0:58
  SPEAKER_01: Greg DeKin, President of Product Management here at MeshIQ, will help us look at this from the enterprise, the governance, and product perspective, and Gore Basou, the vice president of engineering here at MeshIQ, will take us through what is underneath the hood and explain how it actually works technically.
• 1:15
  SPEAKER_01: So we're going to talk about Agent IQ, why MeshIQ believes that AI agent governance needs to happen inside the agent's X execution flow, how organizations can apply policies without killing autonomy, and what this means for security, for compliance, and for cost, and ultimately putting agents into production.
• 1:35
  SPEAKER_01: Greg, I would love to start with the reason we're having this conversation in the first place.
• 1:39
  SPEAKER_01: This year's headlines kept showing the same problem.
• 1:42
  SPEAKER_01: An agent was blocked or at told to ask first, and it acted anyways.
• 1:46
  SPEAKER_01: What problem is Agent IQ solving and why does it need solving now rather than in two years?
• 1:52
  SPEAKER_00: Yeah, thanks, Mike.
• 1:52
  SPEAKER_00: I'll start with why now.
• 1:54
  SPEAKER_00: I think two years is way too long to wait.
• 1:58
  SPEAKER_00: Just thinking back over the last couple years when Chat GPT first kind of launched a little over longer than that, it's come a long way.
• 2:06
  SPEAKER_00: What used to be, I could type something in a chat window and it would give me a pretty robust answer in more human readable language, not just a summary of different links to today AI agents that are connecting to multiple tools and autonomously making decisions and doing things that the person who created the AI agent had no idea that it was going to do.
• 2:30
  SPEAKER_00: So I look back over the last 20 plus years of my career and looking at how things quickly evolve.
• 2:38
  SPEAKER_00: And you want to be at the forefront of those evolutions and not acting in a more reactive sense.
• 2:44
  SPEAKER_00: When I first started my career, we were taking physical servers and we were introducing virtualization.
• 2:49
  SPEAKER_00: And what that allowed us to do was we could more easily put servers in the hands of the developers or the systems that needed them.
• 2:58
  SPEAKER_00: And then fast forward to cloud computing, everyone in the organization had a credit card.
• 3:03
  SPEAKER_00: They could go get their own server and not wait for a slower IT team.
• 3:09
  SPEAKER_00: And what we're seeing with AI is it's happening at a much exponentially rapid pace in terms of how quickly people are able to create AI agents.
• 3:19
  SPEAKER_00: It's not just the software engineering team that's creating these AI agents, it's across the entire enterprise.
• 3:25
  SPEAKER_00: I was talking to a customer that they have an uh initiative from the CEO that everyone in the company should be looking at how they can create their own AI agents in order to solve some of their problems.
• 3:37
  SPEAKER_00: It's not to replace them, it's to ensure that they can grow at a much rapid pace.
• 3:43
  SPEAKER_00: So the the time to act is certainly now.
• 3:46
  SPEAKER_00: This this technology is growing at a very fast pace.
• 3:50
  SPEAKER_00: And so it's important to be aware of not only what AI can do today, but thinking about what it can do in the future, because the future is happening very quickly.
• 4:01
  SPEAKER_00: Some of the pie in the sky ideas that people had with AI two or three years ago seemed so far away, but they're actually happening today.
• 4:09
  SPEAKER_00: So I think that when it comes to AI, you have to have a very forceful defensive posture with what these AI agents can do and be positioned to not only stop them when you need to stop them, but fully understand, audit them, observe them, and know what they're doing as your team is growing in terms of how many AI agents they're deploying, because it's not going to be one or two, it's going to be thousands.
• 4:34
  SPEAKER_01: That distinction between an AI system giving you simply an answer and an AI system actually taking action is critical.
• 4:39
  SPEAKER_01: Once software can act on it behalf of people, visibility alone isn't enough.
• 4:44
  SPEAKER_01: You need control.
• 4:45
  SPEAKER_01: But that also rises what I think is a fair question.
• 4:48
  SPEAKER_01: Mesh IQ isn't a company that suddenly appeared because AI agents became popular.
• 4:53
  SPEAKER_01: You've spent decades working around some of the most critical transaction infrastructure inside large enterprises.
• 4:58
  SPEAKER_01: So, Greg, connect those two worlds for us.
• 5:00
  SPEAKER_01: MeshIQ has spent 25 years governing enterprise message traffic.
• 5:05
  SPEAKER_01: Why is middleware company the right one to govern AI agents?
• 5:10
  SPEAKER_00: That's a good question.
• 5:11
  SPEAKER_00: We at MeshIQ have seen quite an evolution just within our company over the last several years.
• 5:16
  SPEAKER_00: When we work with our customers 20 plus years ago, they are predominantly the IBM and Q team.
• 5:22
  SPEAKER_00: They were focused on a specific middleware technology with a specific use case.
• 5:27
  SPEAKER_00: And as those teams have grown, the technology that they use have certainly grown and expanded.
• 5:34
  SPEAKER_00: We as a company have expanded with them.
• 5:36
  SPEAKER_00: And we have branched out over the last several years to go beyond specific middleware technologies and become more of a multi-middleware technology.
• 5:47
  SPEAKER_00: So it's these our customers and folks, seven of the top 10 banks are using us for that specific reason.
• 5:55
  SPEAKER_00: And they are not just using us for one specific technology.
• 5:58
  SPEAKER_00: So we have over the time taking the solid governance that we have built into our platform, the single API layer.
• 6:06
  SPEAKER_00: We've had machine learning as part of our platform for several years, and we're bringing it all together and expanding as these teams go from middleware-specific teams to entire data in motion integration teams.
• 6:19
  SPEAKER_00: And when it comes to AI, the data is the most important aspect of it.
• 6:24
  SPEAKER_00: These AI agents, based on the data that it has access to, the tools it has access to, which is many, you need to ensure that data is up to date.
• 6:34
  SPEAKER_00: It's the best data possible so that as it's making autonomous decisions, it is gonna make the right decision and help actually do what the use case it was designed to do.
• 6:45
  SPEAKER_00: So not only is extending our platform into the AI agents make the most sense from us because we have that governance and single data plane, but in order to make AI work, that integration data and motion layer is very critical.
• 7:02
  SPEAKER_00: So bringing those two pieces together into one platform makes the most sense and goes along with what we've been doing over the last several years, which is as our team, as our customers are taking on more responsibility and growing their area, we're able to do that as well with our platform.
• 7:16
  SPEAKER_01: Well, love it.
• 7:17
  SPEAKER_01: Thank you so much, Craig.
• 7:18
  SPEAKER_01: So the the idea isn't that Mesh IQ is abandoning middleware to go be build something unrelated to AI.
• 7:23
  SPEAKER_01: You're applying many of the same principles of governance, control, audibility, and operational intelligence to a new kind of enterprise traffic.
• 7:31
  SPEAKER_00: And Garum and I speak with our customers quite a bit.
• 7:34
  SPEAKER_00: And we over the last year have heard quite a bit from our customers who were predominantly historically focused on that data and motion middleware layer, are now talking about AI agents, not only as the consumers of them, they're developing them, they're a critical piece of how the AI agents work.
• 7:53
  SPEAKER_00: It's just part of what all of our customers are talking about.
• 7:57
  SPEAKER_00: And obviously, it's what you're seeing in the news, and everything is AI because it is not just a IT thing, it's not just a software engineering team.
• 8:06
  SPEAKER_00: It's across the board, everyone is being touched by AI in some way, whether that's good or bad, based on how you look at it.
• 8:13
  SPEAKER_01: Thank you, Greg.
• 8:14
  SPEAKER_01: Saying that we govern an AI agent is one thing, how we actually do it is where it gets really interesting.
• 8:18
  SPEAKER_01: So, Gorb, let's go underneath the hood.
• 8:20
  SPEAKER_01: Most AI governance tools sit outside the agent as a gateway, right?
• 8:24
  SPEAKER_01: What does inflow governance mean technically?
• 8:28
  SPEAKER_01: And what can you do inside the execution path that a gateway can't?
• 8:32
  SPEAKER_02: That's a great question, Mike.
• 8:34
  SPEAKER_02: When you're talking about the governance of the agents, right?
• 8:36
  SPEAKER_02: So there are uh a couple of different approaches you can take.
• 8:40
  SPEAKER_02: So one approach what you have mentioned is working as a gateway, which works as any gateway that the gateway sits between the agent and whatever the third party it's connecting to, either it is an LLM or different systems, enterprise systems.
• 8:52
  SPEAKER_02: Or the other option, what we have decided to go forward with is flow governance, which is basically our governance sits within the agent's execution flow.
• 9:02
  SPEAKER_02: And what it gives us predominantly it gives us a lot more control.
• 9:06
  SPEAKER_02: So what it allows us to do, it's basically it catches every call, however, it is sent to say if it is a sent to now an AI agent, it can make a call to MCP, it can make a direct HTTP call, it can make calls to an ADF SDK.
• 9:21
  SPEAKER_02: So what happens when you are on a gateway, then you have to make sure that all these calls going through gateway.
• 9:26
  SPEAKER_02: If you're not configured any of them, then you are missing that.
• 9:29
  SPEAKER_02: But when you're in the agent's execution plane, the governance layer, the SDK, it basically looks into all of this, and then it can make a unified trace across everything and it can enforce governance on each of them, right?
• 9:43
  SPEAKER_02: Then uh one of the main governance areas is human in the loop.
• 9:47
  SPEAKER_02: Now, for human in the loop, what do we really want?
• 9:50
  SPEAKER_02: We want the agent execution to be paused when a human it is waiting for a human's decision.
• 9:55
  SPEAKER_02: Now, having inflow governance helps us to do that, right?
• 9:59
  SPEAKER_02: So if you are working on a gateway, the gateway might sniff the request, but not necessarily it can pause the agent's execution flow.
• 10:06
  SPEAKER_02: Then uh there are a lot of agent controls you can do primarily around the execution, the iterations the agent is running, the token cost limit, or if the kind of runaway agent, whether you're going to stop it.
• 10:19
  SPEAKER_02: So all these controls you can have if you have your governance sitting inside the agent's execution plane.
• 10:25
  SPEAKER_02: But if it's outside, it's very difficult to have them.
• 10:28
  SPEAKER_02: And then finally, what you can get is a single unified trace across the agent execution and the governance.
• 10:34
  SPEAKER_02: Whoever is the reviewer or the auditor, they can see okay, so what agents try to execute, then what governance policies it triggered, and then if there is a decision authorization to be made, who made the authorization, everything sits on a unified trace that gives an end-to-end visibility as well, along with the governance.
• 10:51
  SPEAKER_02: So these are some of the advantages of having a governance plane.
• 10:55
  SPEAKER_02: So, but what it means is that we need to add support to multiple frameworks, right?
• 11:00
  SPEAKER_02: Because not every SDK, not like unlike a gateway, one single SDK cannot work with all different frameworks because different frameworks have are implemented in different ways, their interceptions and all these points work in a different way.
• 11:14
  SPEAKER_02: But we have been working through those, and at this moment we have a support for Langgraph, OpenAI SDK, True AI, AWS Trends, Google SDK, and we are adding support for other popular agent DK frameworks as well.
• 11:28
  SPEAKER_02: Interesting.
• 11:28
  SPEAKER_01: I think it's a significant distinction.
• 11:30
  SPEAKER_01: A gateway can essentially say, I saw the request come through me.
• 11:34
  SPEAKER_01: What you're describing is much closer to I can see what the agent is attempting to do while it's doing it, regardless of how the action is being called, and I can intervene before execution.
• 11:44
  SPEAKER_01: That intervention isn't necessarily binary.
• 11:47
  SPEAKER_01: It's it doesn't always have to mean allow or block.
• 11:50
  SPEAKER_01: So let's take a work, let's make a tangible with uh with an example.
• 11:54
  SPEAKER_01: Gorub, agent IQ doesn't just allow or block a tool, like I said, it doesn't allow, confirm, escalate, or deny based on the values of each call.
• 12:02
  SPEAKER_01: Walk us through an example.
• 12:04
  SPEAKER_01: If like a refund agent handling$50 versus$50,000, where do those policies live?
• 12:12
  SPEAKER_01: How are they written and versioned?
• 12:14
  SPEAKER_01: Yeah.
• 12:14
  SPEAKER_02: That's a good part.
• 12:15
  SPEAKER_02: So when an agent execution happens, right, we can basically draw a panel to an workflow, a classic workflow.
• 12:23
  SPEAKER_02: Now, on a deterministic workflow, you can design the rules up front, right?
• 12:28
  SPEAKER_02: But on a non and when it's an API agent, what it does, it's a non-deterministic system and it is building the workflow on the go, which is and so it basically creates its own flow and it can use different tools at its disposal to get to the final result, right?
• 12:43
  SPEAKER_02: So you you cannot design the controls up front.
• 12:46
  SPEAKER_02: So what you can do is you basically can govern the whenever the handoff happens from agent to the tools.
• 12:54
  SPEAKER_02: Now, what happens if you can just straight if you just straight away allow or block, then it doesn't give you the capability of the autonomous systems, right?
• 13:02
  SPEAKER_02: The autonomous decision making, which is the main power of agent, if you have to harness that power properly, right?
• 13:07
  SPEAKER_02: So then you have to have you have to build these policies, which is if I if you're referring to the same refund agent.
• 13:15
  SPEAKER_02: For example, if I'm refunding something which is less than$50, it can take autonomous decision, right?
• 13:20
  SPEAKER_02: So it can just go ahead and without any intervention.
• 13:22
  SPEAKER_02: But if it is$1,500 or$1,500, maybe it needs a confirmation of whoever is sitting in front of an agent.
• 13:29
  SPEAKER_02: If it is a$5,000 more, then it probably needs an approval from a supervisor, which is very similar to a workflow human approval kind of things, right?
• 13:38
  SPEAKER_02: And in few cases, you might straight away deny those requests.
• 13:40
  SPEAKER_02: So all of these configurations can be designed as a policy in our agent IQ console.
• 13:46
  SPEAKER_02: This policy is basically the central configurable at the agent IQ server, and then once you basically drag and drop in the UI with the parameters, that is one of the one of the ways we have built this system is we are pre-populating the parameters of all the tools in the console when the agent is attached to the governance of our agent IQ.
• 14:09
  SPEAKER_02: And then so at design time, whoever is enforcing the compliance, they can basically design those rules up front.
• 14:14
  SPEAKER_02: That okay.
• 14:15
  SPEAKER_02: So if it is a below$50, you just allow it, if it's a more than$500, you just confirm and escalate and like that, right?
• 14:22
  SPEAKER_02: So every decision that that's how configure these policies are maintained in a system and it enforces when the agent execution happens.
• 14:30
  SPEAKER_02: And all of these the policies and the approval decisions, everything is captured in our unified trace.
• 14:36
  SPEAKER_02: When some someone audits that what happened to this agent or what happened to this particular refund request, so there's a complete unified trace available for the introspection that what exactly happened.
• 14:48
  SPEAKER_01: I feel like I really love that example.
• 14:50
  SPEAKER_01: It's the the agent hasn't lost its autonomy, it's really just changing the level of autonomy based on the risk.
• 14:55
  SPEAKER_01: $50 refund could just move automatically.
• 14:58
  SPEAKER_01: But a large transaction require confirmation, and something materially risky can stop and wait for the right person before anything happens.
• 15:06
  SPEAKER_01: But enterprises aren't building all of their agents the same way.
• 15:09
  SPEAKER_01: Different teams are already choosing different frameworks, which creates another governance challenge.
• 15:14
  SPEAKER_01: So, Greg, let's talk about that fragmentation.
• 15:17
  SPEAKER_01: Most teams are they have already picked a framework, Landgraph, crew AI, open AI agents, auto gem.
• 15:24
  SPEAKER_01: But how does AI, how does Mesh IQ's agent IQ work across all of them without forcing a team to have to standardize?
• 15:32
  SPEAKER_01: And what does what does integration actually take?
• 15:35
  SPEAKER_01: Yeah.
• 15:36
  SPEAKER_00: Yeah.
• 15:36
  SPEAKER_00: So the core of agent IQ, similar to the core of MeshIQ, is to support you across all the various different, whether it's middleware technologies or AI technologies that you're dealing with.
• 15:48
  SPEAKER_00: We are not finding customers that are all in on one technology that are already facing what you're talking about, Mike.
• 15:54
  SPEAKER_00: Similar to the cloud computing example I gave earlier, back in the day, one group might have a credit card tied to their AWS account, another one had one tied to Azure.
• 16:05
  SPEAKER_00: You acquire a company and they're all in on Google Cloud, and all of a sudden, as an IT team, a security team, a CFO, you're faced with a multi-cloud strategy.
• 16:15
  SPEAKER_00: That's where everyone's been.
• 16:17
  SPEAKER_00: That's the move forward method for cloud.
• 16:20
  SPEAKER_00: It's the same thing for AI.
• 16:22
  SPEAKER_00: Here at MeshIQ, we have teams that use OpenAI because it works well for them.
• 16:27
  SPEAKER_00: We have teams that work use cloud because it worked well for them.
• 16:30
  SPEAKER_00: So that there is just it's each one is could you could say is purpose-built for certain scenarios, and you're going to plug and play based on that.
• 16:39
  SPEAKER_00: And so what we do, somewhat Garab described the technical aspect of we're building STKs that are specific for those frameworks.
• 16:47
  SPEAKER_00: And what we're focused on at Mesh IQ is as you can imagine, the AI landscape is rapidly growing every single day.
• 16:56
  SPEAKER_00: That there's new LLMs coming out, there's new frameworks coming out, there's new MCP servers being spun up, different endpoints that different AI agents want to communicate with.
• 17:06
  SPEAKER_00: And so we are rapidly evolving and attempting to stay ahead of that by building this out.
• 17:11
  SPEAKER_00: And what that allows is, as you mentioned, Mike, we're not in a place where we're forcing you to choose one framework or the other.
• 17:18
  SPEAKER_00: And so we're open to all of them and working with all of them.
• 17:22
  SPEAKER_00: And that's the the value of what we see in agent IQ is that you bring on any new team that's using a different framework, but allow us to centralize things so that you have that central governance, central policies.
• 17:35
  SPEAKER_00: That's the great thing, is you're not allowed you're not waiting for individual teams to build in some of those scenarios that Gaurab just mentioned.
• 17:44
  SPEAKER_00: You can do it in one place, one policy that could apply across all the different AI agents that are dealing with certain things at a dollar value amount, refund amount.
• 17:54
  SPEAKER_00: You can do that all in one place.
• 17:55
  SPEAKER_00: So that's really the value of what we see moving forward is that we're taking the governance, the cost avoidance out of the individual teams and putting that in a central tool such as agent IQ.
• 18:07
  SPEAKER_01: I suspect that it's very important to any developers listening because governance becomes much harder to adopt if the answer is first rewrite all of your agents using our framework.
• 18:18
  SPEAKER_01: The goal here is to govern what teams are actually and already building rather than dictate how they have to build it.
• 18:25
  SPEAKER_01: Once you make that possible, though, the conversation very quickly becomes a security conversation.
• 18:30
  SPEAKER_01: Gorb, let's start with one of the attack vectors getting a tremendous amount of attention right now.
• 18:37
  SPEAKER_01: Let's get into prompt injection.
• 18:40
  SPEAKER_01: How are attempts scored and stopped before they reach a tool?
• 18:44
  SPEAKER_01: And how do band topics work alongside that?
• 18:48
  SPEAKER_02: We do have the capability to basically, once someone inputs a prompt to an agent, so we can pause the execution of the agent and we can run that prompt through some of our systems, and we can identify some kind of a confidence score.
• 19:03
  SPEAKER_02: Then what is the probability of this prompt being a prompt injection, right?
• 19:07
  SPEAKER_02: And then based on that probability, we can define policies.
• 19:10
  SPEAKER_02: And here also it's configurable the same way that you can say, okay, if there is a certain phrase which is absolute with absolute certainty, the system can predict its uh prompt injection.
• 19:21
  SPEAKER_02: So it can generate a threshold score of one, right?
• 19:24
  SPEAKER_02: Basically a confidence score of one.
• 19:25
  SPEAKER_02: Then you can define a threshold, say, for example, if anything is above 0.8, then you deny it, right?
• 19:33
  SPEAKER_02: Or if anything is between 0.5 to 0.8, then you are unsure that it might be a prompt injection, or it can be a normal request as well.
• 19:42
  SPEAKER_02: So in that case, you may not want to straight away deny it, but you might want to send it for a human evaluation.
• 19:48
  SPEAKER_02: And that's where you trigger the human in the loop and you send it for an approval.
• 19:51
  SPEAKER_02: And then something which is a very small three, sure, very small amount, that means you are definitely sure it's not a prompt injection.
• 19:57
  SPEAKER_02: So you can just straight away allow that rig.
• 19:59
  SPEAKER_02: So it's basically the same policy configuration of this allow, confirm, escalate, and deny.
• 20:05
  SPEAKER_02: We can run it through the confidence score of the prompt request or prompt we are receiving at the system, and our governance can enforce that, right?
• 20:13
  SPEAKER_02: So these policies can be configured at the agent level, as well as these policies can be configured at global level as well.
• 20:20
  SPEAKER_02: Once we can create a zero trust uh policy at the global level, and then any agent which registers itself with agent IQ, then from the moment the registration happens, all these policies are enforced for the agent.
• 20:35
  SPEAKER_02: So on the same note, what you have talked about band topics.
• 20:37
  SPEAKER_02: So we have a similar way we can identify the topics from the input prompt.
• 20:42
  SPEAKER_02: And say, for example, if enterprises definitely have policies that okay, so you might not want to have your agent allow to respond to say topics like politics, religion, or sport or any other topics, right?
• 20:56
  SPEAKER_02: Once you integrate that, then you can also similarly have the same confidence score for the same, and you can allow or escalate or deny these requests based on whatever the inputs are coming.
• 21:08
  SPEAKER_02: So these are like a blacklisting of the topics.
• 21:10
  SPEAKER_02: You can even whitelist the topics as well.
• 21:12
  SPEAKER_02: You can say, okay, my agent, if it will only talk about these things, and then you can whitelist, then you basically putting a guardrail around the agent, then okay, this agent will only respond to certain these topics and not any other topics, right?
• 21:24
  SPEAKER_02: So these are the combinations.
• 21:25
  SPEAKER_02: Then there are some other capabilities as well.
• 21:27
  SPEAKER_02: You can be banned in giving code as an input, right?
• 21:31
  SPEAKER_02: Because we have seen there are multiple instances happen that agents get access to the systems and gone out of the sandbox.
• 21:39
  SPEAKER_02: Primarily, the agents are basically able to execute the queries, right?
• 21:42
  SPEAKER_02: We can even block those kinds of things.
• 21:44
  SPEAKER_02: It can be you can have deterministic blocks, like either a certain phrase you don't allow, or you do not allow code snippet and all these kinds of controls.
• 21:53
  SPEAKER_02: So you have just as an overall control the security basically the radial last week.
• 21:58
  SPEAKER_01: I think it's important because you're effectively.
• 22:00
  SPEAKER_01: Moving security earlier in the execution path.
• 22:02
  SPEAKER_01: Instead of discovering that the agent did something inappropriate after the fact, you're evaluating the request before the action occurs.
• 22:09
  SPEAKER_01: And there's another version of that same principle that applies to data.
• 22:13
  SPEAKER_01: It isn't enough to prevent sense information from some appearing in the final response.
• 22:17
  SPEAKER_01: If that information has already been sent somewhere, it shouldn't have gone.
• 22:21
  SPEAKER_01: Agent IQ, it masks personal identifiable information before it reaches the model, not just before the user sees a response.
• 22:29
  SPEAKER_01: Why does that distinction matter?
• 22:31
  SPEAKER_01: And how do you mask data without breaking the agent's ability to finish the task?
• 22:35
  SPEAKER_02: Yeah.
• 22:36
  SPEAKER_02: So when I talked with many of our customers, right?
• 22:39
  SPEAKER_02: So this was one of their bigger concerns that so once something goes inside the model, there is not really a visibility what happens with the data, right?
• 22:48
  SPEAKER_02: And for sensitive data like PIA data or any other sensitive data, like your card information, financial information, and any of the sensitive data.
• 22:57
  SPEAKER_02: So not any enterprise is comfortable of handing that data over to any model.
• 23:02
  SPEAKER_02: So not even the end person who's the data that belongs to, right?
• 23:08
  SPEAKER_02: So that is why we built that capability so that whenever an agent executes, so before every time it makes a call to uh LLM, we we have this configurable masking in the system.
• 23:20
  SPEAKER_02: There are our some predefined masking available already, like some of the standard SSN and credit card information and PI data, but then it's configurable as well, right?
• 23:31
  SPEAKER_02: Any enterprise can configure based on their the data which they think is that is sensitive.
• 23:36
  SPEAKER_02: And so we mask the data before it goes to relevant, and even you mask the data before the agent sends a response in the chat output as well, right?
• 23:43
  SPEAKER_02: So it's a both of a mask, but what you do not do so whatever the data is valuable is when it goes to the system of records, which actually needs the data to get the information and do that, right?
• 23:55
  SPEAKER_02: So we make sure that when it goes to the system of record, that time the actual data passes along.
• 24:00
  SPEAKER_02: That's why to your question that it doesn't take away the capital of the agents to work on the data, but still making sure that the LLMs and the users don't see that it is massive.
• 24:10
  SPEAKER_01: So the system of record can still know who the customer is and complete the transaction, but the language model doesn't necessarily need access to that person's actual sense of information.
• 24:20
  SPEAKER_01: That's a subtle distinction, technically, but a pretty significant one from a privacy and governance standpoint.
• 24:27
  SPEAKER_01: Now, whenever you start adding security controls, policy evaluation and inspection into a transaction path, I know what some of the engineers listening are probably thinking.
• 24:38
  SPEAKER_01: That sounds great.
• 24:40
  SPEAKER_01: But what is actually what is it going to do to performance and to cost?
• 24:45
  SPEAKER_02: Maybe I can start with cost.
• 24:47
  SPEAKER_02: So we don't make any LLM calls on ourselves, right?
• 24:50
  SPEAKER_02: So it's whatever the LM calls agents are making, it's just that.
• 24:53
  SPEAKER_02: So whatever the decision we make, we have our inbuilt capabilities or built, we are making those decisions out of that.
• 24:59
  SPEAKER_02: So we doesn't add to the LLM cost to start with.
• 25:02
  SPEAKER_02: And in terms of the speed, so what basically the this whole capability of conditional policies, right?
• 25:09
  SPEAKER_02: That you can either for certain requests you can allow it for certain requests, you can send it for human review for certain requests you can deny.
• 25:17
  SPEAKER_02: So what it actively does, it allows to actually to basically embrace the power of the autonomous, right?
• 25:24
  SPEAKER_02: Without losing the control.
• 25:26
  SPEAKER_02: So what happens if you have scenarios that either you say okay, these are too risky of an operation, so we do not allow it for the agents, right?
• 25:36
  SPEAKER_02: Then you'll end up with okay, so your agents will only work with read use cases.
• 25:41
  SPEAKER_02: You cannot have the autonomous decisions on a vast majority of use cases where editing and writing and changing of the data is involved, right?
• 25:50
  SPEAKER_02: That's basically limiting the capability of an agent.
• 25:53
  SPEAKER_02: So the what our platform offers is this conditional decision making, which helps you to basically speed up the autonomous decision making and agents execution runs even uh faster and in more many of the use cases where it can take autonomous decisions, which without this, you probably would have the user probably would have decided not to allow agents to go with those operations, right?
• 26:18
  SPEAKER_01: So, yeah, that'll be my answer to that.
• 26:20
  SPEAKER_01: It brings up another cost issue that actually might be bigger than the cost of governance itself.
• 26:25
  SPEAKER_01: Once an agent becomes autonomous, they can also autonomously consume resources, an employee eventually goes home.
• 26:31
  SPEAKER_01: An agent stuck in a loop does not, right?
• 26:33
  SPEAKER_01: What does a runway agent look like in production?
• 26:36
  SPEAKER_01: And how does cost observability, token caps, and loop limits catch it?
• 26:41
  SPEAKER_02: When we've been talking with some of our customers and some of prospects, so this is also one of the bigger concerns, and primarily for the person who is accountable for the budget, right?
• 26:53
  SPEAKER_02: So no one really has a control that what is the workflow that the agent is finally is agent is deciding to take to solve the particular problem.
• 27:03
  SPEAKER_02: So now in in quite a few instances, it happens that it goes into a rabbit hole of a path where it basically navigates multiple tools and it runs on multiple loops.
• 27:15
  SPEAKER_02: And the thing is for that is the main distinction, which is very new to these agetic systems, right?
• 27:21
  SPEAKER_02: Because for a deterministic workflow, you design the path upfront.
• 27:26
  SPEAKER_02: So you know which path it's going to take.
• 27:28
  SPEAKER_02: So even if it costs something, you know that's a fixed cost.
• 27:31
  SPEAKER_02: But here, as because you you have not built the path up front, so if the agent decides to take a longer route, you have no control over it, right?
• 27:41
  SPEAKER_02: At the end of the day, it just shows up on the bill which you are receiving from the model providers, because every time it makes a call to LLM, it gives you the token cost and it bills against that, right?
• 27:54
  SPEAKER_02: The capabilities, what you have thought of, we could to at least make sure that the run of agents are not emptying the coffer.
• 28:00
  SPEAKER_02: So we have added few capabilities of iteration limit.
• 28:04
  SPEAKER_02: If you say that if an agent is running, you can predetermine that okay, for my certain these use cases, my agent probably can solve this problem with 10 iterations.
• 28:13
  SPEAKER_02: But if it is goes more than 10 iterations, then probably there is something wrong.
• 28:16
  SPEAKER_02: So you should it works as a stop loss, right?
• 28:18
  SPEAKER_02: And pretty similar to there's a token limit as well, because not necessarily the iteration, even if it's possible in single iteration, the token consumption goes very high.
• 28:27
  SPEAKER_02: It because it all depends on the kind of data you are getting from the tools.
• 28:31
  SPEAKER_02: If you're gonna get a lot of data from the tools, and all those data, if you send it to the models, everything adds up on your token cost, and that eventually, even with smaller number of iterations, you can your token cost can blow up significantly.
• 28:45
  SPEAKER_02: So there is uh primarily two of these controls.
• 28:48
  SPEAKER_02: One is the iteration control, and another is the cost control on the tokens.
• 28:51
  SPEAKER_02: There are multiple use cases for this, and the more complex workflow is, there is a higher chance.
• 28:56
  SPEAKER_02: If it is a very simple workflow, it's just reading a system, then probably this may not be that much of a concern.
• 29:01
  SPEAKER_02: But the more complex the workflows become, these problems can come up.
• 29:06
  SPEAKER_02: Very, how do I put it?
• 29:07
  SPEAKER_02: It's very difficult to predict that.
• 29:09
  SPEAKER_02: When do you suddenly encounter this situation?
• 29:12
  SPEAKER_02: Unless you have this control.
• 29:14
  SPEAKER_02: The only thing is that you will suddenly get a big bill from the model providers.
• 29:18
  SPEAKER_01: So I think that's an interesting shift on how companies may have to think about fin ops as ages become more common.
• 29:24
  SPEAKER_01: Instead of only asking what we're spending on a model or cloud provider organizations, may have to start asking, what is this particular agent costing us?
• 29:33
  SPEAKER_01: What business outcomes is it producing?
• 29:36
  SPEAKER_01: And is its behavior staying inside the boundaries we've established?
• 29:40
  SPEAKER_01: Which agents it brings us to the people who are ultimately going to care about all of this.
• 29:46
  SPEAKER_01: Greg, there are really two audiences here.
• 29:50
  SPEAKER_01: They don't necessarily wake up worrying about the same things.
• 29:54
  SPEAKER_01: Two very different people care about this: the CISO or the chief AI officer on one side, and the head of AI and platform lead on the other.
• 30:04
  SPEAKER_01: How does each of them see agent IQ?
• 30:07
  SPEAKER_01: What which industries even are feeding or feeling that pressure first?
• 30:12
  SPEAKER_00: Yeah.
• 30:13
  SPEAKER_00: So when we start to talk about this in the context of AI, this is really a natural extension of what MeshIQ, what we've been doing for the last 20 plus years with the middleware data and motion integration teams, is you're constantly pressured.
• 30:28
  SPEAKER_00: I would say another audience would be the finance team, the CFO is looking at how to control costs.
• 30:35
  SPEAKER_00: And as an IT person, you're constantly faced with how to lower costs, how to provide better service, quicker service.
• 30:42
  SPEAKER_00: So you're always looking at the metrics around mean time to resolution, mean time just to respond sometimes.
• 30:48
  SPEAKER_00: And then when it comes to security, how to make it more secure and the number of certifications, audits that you go through, you have to have all that control around.
• 30:58
  SPEAKER_00: So it's a crunch on these teams.
• 30:59
  SPEAKER_00: And what we've done over the last 20 plus years at MeshIQ is provide tools that allow them to push some of that work out of their teams to a more economical sense team and allow resolutions to happen much quicker.
• 31:15
  SPEAKER_00: And so what we've done with some of our middleware teams is usually those teams are a smaller team.
• 31:21
  SPEAKER_00: And so they're faced with always having to respond to everything middleware related.
• 31:25
  SPEAKER_00: And our tools have allowed them to give some more self-service to the frontline support teams, the second-level support team, so that they're taking work off of their plate and putting it onto another team, which allows the customer to get a quicker resolution at a lower cost.
• 31:44
  SPEAKER_00: So they're able to, with our platform, show how they're able to shift that cost.
• 31:49
  SPEAKER_00: And with the deep governance that we have, they're able to show that it's still a secure method to do so.
• 31:55
  SPEAKER_00: So as this happens with AI, it's just exploding at a much higher rate.
• 31:59
  SPEAKER_00: It's not just the middleware team, it's every team across the enterprise IT team is faced with this.
• 32:06
  SPEAKER_00: So, how to ensure that there's this battle of how much is this actually costing?
• 32:12
  SPEAKER_00: Is it secure?
• 32:13
  SPEAKER_00: Is it actually resolving the issue that we want it to resolve?
• 32:16
  SPEAKER_00: And so all of those are coming together and having one central place to govern it all really helps teams to more quickly do that and adopt some of these AI agents that they're being asked to develop.
• 32:28
  SPEAKER_00: We've talked to the business user side where they're being tasked with, well, what kind of how can you speed up resolution to your customers?
• 32:36
  SPEAKER_00: And right now the answer is building these AI agents and deploying them.
• 32:40
  SPEAKER_00: And it's constantly a battle between all these teams of what's the what makes the most economical sense, what is making it more secure, and how can we ensure that we're still able to deliver to our customers at a high, high rate, even if it's some of these unknown autonomous AI agents doing some of the work.
• 32:58
  SPEAKER_01: That's really the balancing act behind this higher conversation.
• 33:02
  SPEAKER_01: Security and compliance teams, they want to control developers, they want freedom.
• 33:06
  SPEAKER_01: And the organization actually needs both.
• 33:08
  SPEAKER_01: If governments make development impossible, teams will work around it.
• 33:13
  SPEAKER_01: If autonomy comes without accountability, the enterprise carries a tremendous amount of risk.
• 33:17
  SPEAKER_01: And eventually someone is going to ask the question every regulated organization knows is coming.
• 33:22
  SPEAKER_01: Show me exactly what happened.
• 33:24
  SPEAKER_01: So when an auditor or a regulator asks what an agent did, why it did it, and who approved it, what does IQ hand them?
• 33:33
  SPEAKER_00: Yeah, so it's much different than handing over source code, or here's some procedures that the team follows when certain things come into play.
• 33:42
  SPEAKER_00: Now it's this autonomous AI agent that, for lack of better words, could do anything without something like agent IQ to help assist it.
• 33:49
  SPEAKER_00: So what we are able to provide is down to the individual trace level of okay, the end user put in this into the text box.
• 34:00
  SPEAKER_00: This is what the AI agent did.
• 34:02
  SPEAKER_00: It accessed these tools with this permission, it accessed, it sent this information to the LLM.
• 34:08
  SPEAKER_00: And all this back and forth is what's captured within our product.
• 34:12
  SPEAKER_00: It's in a format that's easily consumable by someone in the UI, but similar to our MeshIQ platform for the middleware and integration teams, it's all backed by a very powerful data store that's easily exportable to give to an auditor to see what happened there.
• 34:28
  SPEAKER_00: So that type of audit level that we have built into the platform is helpful not only for those security audits, but also is helpful for developers because as a developer of anything, you know you're eventually going to be asked, how can you make it faster?
• 34:44
  SPEAKER_00: How can you make it cheaper?
• 34:45
  SPEAKER_00: And so this level of detail that we're able to provide in the product helps to solve a lot of those problems.
• 34:51
  SPEAKER_00: And you know, it's that level of detail that in one central place is critical because if you're using all these different frameworks without any tooling like agent IQ, you're now pulling from OpenAI, from Claude, from Lane, you're having to go all these different tools to pull in all this information where now we have one central place to help some of that audit and secure as well as the financial reconciliation happen in one place.
• 35:19
  SPEAKER_01: I think that closes the loop rather nicely.
• 35:21
  SPEAKER_01: We've gone from knowing what an agent what agents exist to controlling what they're actually allowed to do, protecting the information they interact with, understanding what they're costing, and finally being able to reconstruct exactly what happened afterwards.
• 35:34
  SPEAKER_01: But technology like this ultimately has to prove itself in the real world.
• 35:38
  SPEAKER_01: So I'd like to finish with something very practical for anybody and everyone and anyone listening who is either experimenting with agents today or even preparing to move them into production.
• 35:49
  SPEAKER_01: Let's imagine a company starting a 30-day agent IQ proof of concept.
• 35:55
  SPEAKER_01: First, what should they actually measure during those 30 days to know whether this is working?
• 36:01
  SPEAKER_01: And then I'd like to finish with both of you individually.
• 36:04
  SPEAKER_01: If you could give me one piece of advice to a team that is just beginning to move agents uh into experimentation, into real enterprise workflows, what would that piece of advice be?
• 36:16
  SPEAKER_01: Gorub, let's start with you and then Greg, I'll give you a final word.
• 36:20
  SPEAKER_02: So when basically think about this technology, I remember that phrase from the piece of Spider-Man, right?
• 36:25
  SPEAKER_02: So it's with great power, you get great responsibility, you have to have great responsibility.
• 36:30
  SPEAKER_02: See, these systems are insanely powerful.
• 36:32
  SPEAKER_02: There is no two way about it.
• 36:34
  SPEAKER_02: Now, and the thing is on top of that, the non-deterministic nature of these systems.
• 36:38
  SPEAKER_02: So when you combine these two, so the responsibility becomes that the governance and observability cannot come as an afterthought once everything is done and you are ready to go to production.
• 36:51
  SPEAKER_02: So these two, the observability and governance should go hand in hand when someone is developing an agent, right?
• 36:58
  SPEAKER_02: And that will be probably my advice to any teams who is trying to build their build agents and get into developing the custom agents.
• 37:05
  SPEAKER_02: And on both of these fronts, agent IQ can really help me with end-to-end tracing, the overall cost, uh, the overview of how even in the loop and the control of the policies and the agent control of the iteration.
• 37:20
  SPEAKER_02: So many of these capabilities what you have in the platform.
• 37:23
  SPEAKER_02: This gives these both governance as well as the observability, which we definitely think is a must for every team starting to build custom workflows at enterprise level with a yeah.
• 37:36
  SPEAKER_00: I would add on to that that as I I mentioned, I think several times, this this area is evolving so quickly.
• 37:43
  SPEAKER_00: So when you build the AI agent today, in two weeks, there's gonna be an evolution of the LLM that it's interacting with.
• 37:50
  SPEAKER_00: There's gonna be an evolution of the tools and different endpoints that it's interacting with.
• 37:55
  SPEAKER_00: It's just autonomous in nature.
• 37:57
  SPEAKER_00: It's gonna start to decide what else it can do.
• 38:00
  SPEAKER_00: So, my suggestion is at a minimum, start with something that can observe and understand all the different traces and actions that an agent is taking so that you can see over time when it's starting to maybe do things beyond what you envisioned when you first created the AI agent.
• 38:19
  SPEAKER_00: What you really need to do when you move into production is go with more of a zero trust idea, which is core of what we are doing with the agent IQ, is create the policy so that it can only do what you want it to do.
• 38:32
  SPEAKER_00: And then as it autonomously starts to decide it wants to take different routes, you're feeling safe that you can actually stop them from happening or raise them up to the human in the loop that that Gorob mentioned, where dynamically, based on what it's trying to do, it would raise it up for some kind of approval or just full-on stop it.
• 38:51
  SPEAKER_00: So those my two suggestions is that this is moving way too quickly.
• 38:54
  SPEAKER_00: If you're building an AI agent, you have to know what it's doing.
• 38:59
  SPEAKER_00: And then as you move to production, you should go to more of a zero trust model where you're telling it exactly what it can do, and everything else it just can't do.
• 39:09
  SPEAKER_01: Thank you both so much, Gorub, Greg.
• 39:10
  SPEAKER_01: I can't thank you enough for your time.
• 39:12
  SPEAKER_01: I think the biggest takeaway for me from today's discussion is that the conversation around enterprise AI is changing very quickly for the last few years.
• 39:19
  SPEAKER_01: Much of the focus has been on what AI can generate, but now we're entering into this phase where the much bigger question is what AI is allowed to do, right?
• 39:28
  SPEAKER_01: As agents gain access to enterprise applications, the APIs, customer information, financial systems, and business processes, organizations, they need a way to give those agents enough autonomy to be useful without giving up visibility, security, control.
• 39:42
  SPEAKER_01: And as we've heard today, that means knowing which agents are operating, understanding every action they take, applying policy based on context of that action, protecting sensitive information, controlling the cost, obviously, and introducing a human when risk demands it.
• 40:00
  SPEAKER_01: And I think maintaining an audit trail of exactly what happened is key.
• 40:03
  SPEAKER_01: What's the problem?
• 40:05
  SPEAKER_01: No, I think that that is the problem that AgentIQ is designed to address.
• 40:09
  SPEAKER_01: Gorub, Greg, thank you again for taking us through both the product and the technology behind it.
• 40:15
  SPEAKER_01: And thank you to everyone who joined today.
• 40:17
  SPEAKER_01: If what you heard raised questions about how your organization is governing the agents you've already built, are building or planning to deploy, we'd be happy to continue the conversation and show you exactly how AgentIQ looks in action.
• 40:32
  SPEAKER_01: Thanks again for spending time with us today.
• 40:35
  SPEAKER_01: I hope to see you all in the next web mesh IQ webinar, listen to our next podcast, and just stay in touch.
• 40:41
  SPEAKER_01: We're here to help whenever needed.